From b6c834bc2a362a0fff5ea6322e7288cf706db705 Mon Sep 17 00:00:00 2001
From: Gzure <740684863@qq.com>
Date: Mon, 17 Aug 2026 14:51:30 +0800
Subject: [PATCH 01/11] Add handshake transport design

---
 docs/cn/handshake_common_design.md | 754 +++++++++++++++++++++++++++++
 1 file changed, 754 insertions(+)
 create mode 100644 docs/cn/handshake_common_design.md

diff --git a/docs/cn/handshake_common_design.md b/docs/cn/handshake_common_design.md
new file mode 100644
index 0000000000..3a79580d74
--- /dev/null
+++ b/docs/cn/handshake_common_design.md
@@ -0,0 +1,754 @@
+# RDMA、URMA 与 UBSHM 公共握手组件设计方案
+
+## 1. 背景
+
+brpc 当前有三种基于 TCP 建立控制连接、再切换到高速数据面的传输：
+
+- RDMA：`src/brpc/rdma/rdma_endpoint.*`
+- URMA：`src/brpc/urma/urma_endpoint.*`
+- UBSHM/UBRING：`src/brpc/ubshm/ub_endpoint.*`
+
+三套实现都包含以下流程：
+
+```text
+TCP 连接建立
+    -> 发送本地 Hello
+    -> 接收并校验对端 Hello
+    -> 创建或导入高速传输资源
+    -> 返回协商结果/ACK
+    -> 成功切换高速通道，或回退到 TCP
+```
+
+目前公共流程主要以复制代码的形式存在。例如：
+
+- RDMA 的 TCP 握手读写循环在 `rdma_endpoint.cpp` 中实现；
+- URMA 在 `urma_endpoint.cpp` 中重新实现了一套；
+- UBSHM 在 `ub_endpoint.cpp` 中再次实现了一套；
+- 三套实现都维护独立的握手状态枚举、client/server 流程和 fallback 逻辑。
+
+本方案只抽取握手公共组件，不尝试合并 RDMA QP、URMA Jetty 或 UBSHM ring 的数据面实现。
+
+## 2. 现状分析
+
+### 2.1 RDMA
+
+RDMA 支持：
+
+- v2 二进制握手：`RDMA` magic；
+- v3 protobuf 握手：`RDM3` magic；
+- client/server 两套解析路径；
+- server 侧基于 `butil::IOBuf` 的增量解析；
+- 非 RDMA 连接的 TCP fallback；
+- 4 字节 ACK。
+
+相关代码：
+
+- `src/brpc/rdma/rdma_handshake.h`
+- `src/brpc/rdma/rdma_handshake.cpp`
+- `src/brpc/rdma/rdma_handshake_server.cpp`
+
+### 2.2 URMA
+
+URMA 的握手结构与 RDMA 类似，但 payload 完全不同：
+
+- v2 二进制握手：`URMA` magic；
+- v3 protobuf 握手：`URM3` magic；
+- Hello 中携带 EID、UASID、Jetty、segment 和 token 信息；
+- 需要先导入 remote segment，再导入 remote Jetty；
+- 目前 server/client 主要由 `UrmaEndpoint` 自己驱动。
+
+相关代码：
+
+- `src/brpc/urma/urma_handshake.h`
+- `src/brpc/urma/urma_handshake.cpp`
+- `src/brpc/urma/urma_endpoint.cpp`
+
+### 2.3 UBSHM/UBRING
+
+UBSHM 当前使用固定长度二进制握手：
+
+```text
+[ "UB" 2B ][ HelloMessage 62B ]
+```
+
+Hello 中携带：
+
+- `msg_len`
+- `hello_ver`
+- `impl_ver`
+- shared memory 长度
+- shared memory 名称
+
+握手成功后，通过 ACK 中的 `UB_OK` bit 表示是否切换到 UBRING；失败时回退 TCP。
+
+相关代码：
+
+- `src/brpc/ubshm/ub_endpoint.h`
+- `src/brpc/ubshm/ub_endpoint.cpp:63`
+- `src/brpc/ubshm/ub_endpoint.cpp:331`
+- `src/brpc/ubshm/ub_endpoint.cpp:460`
+
+## 3. 设计目标
+
+### 3.1 目标
+
+1. 消除三套实现中的 TCP 握手读写重复代码。
+2. 统一 magic、长度、版本、ACK、fallback 和错误结果的处理方式。
+3. 支持 client 阻塞式读取和 server 基于 `IOBuf` 的增量读取。
+4. 保持 RDMA、URMA、UBSHM 的现有 wire format 完全兼容。
+5. 让协议 payload 和高速资源协商逻辑继续由各传输实现负责。
+6. 在未开启某一传输宏时，公共组件仍可独立编译。
+
+### 3.2 非目标
+
+本次不抽取以下内容：
+
+- RDMA QP/CQ/PD/MR 创建和销毁；
+- URMA Jetty/JFR/JFC/segment 导入；
+- UBSHM ring 和 shared memory 映射；
+- RDMA、URMA、UBSHM 的数据面 completion 处理；
+- 三种传输的内存池；
+- 三种传输的 poller/CQ 事件线程。
+
+这些组件虽然也存在结构相似性，但资源模型不同，过早抽象会导致公共接口暴露 `ibv_*`、`urma_*` 或 UBRING 类型。
+
+## 4. 总体架构
+
+新增公共目录：
+
+```text
+src/brpc/handshake/
+    handshake_common.h       # 结果、角色、错误和阶段定义
+    handshake_io.h            # 字节流抽象
+    handshake_io.cpp
+    handshake_frame.h         # magic/长度/增量帧解析工具
+    handshake_frame.cpp
+    handshake_driver.h        # 通用握手驱动
+    handshake_driver.cpp
+```
+
+总体关系如下：
+
+```text
+                 +--------------------------+
+                 |     HandshakeDriver       |
+                 | client/server state flow  |
+                 +------------+-------------+
+                              |
+                 +------------v-------------+
+                 |   HandshakeProtocol       |
+                 | build/parse/validate hello|
+                 | build/parse ack           |
+                 +--+-------------+----------+
+                    |             |
+          +---------v--+     +----v---------+
+          | HandshakeIO|     | FrameCodec   |
+          | read/write |     | magic/length |
+          +---------+--+     +--------------+
+                    |
+       +------------+-------------+-------------+
+       |                          |             |
+  RDMA adapter               URMA adapter   UBSHM adapter
+```
+
+公共组件只负责握手过程和字节帧，不负责判断“创建 QP、导入 Jetty 还是映射 SHM”。
+
+## 4.1 两种候选架构对比
+
+本节同时保留两种方案，便于社区讨论握手组件应该放在哪一层。
+
+### 方案 A：公共握手组件与各类 Endpoint 组合
+
+这是上一版设计的方向：公共组件提供 `HandshakeIO`、`FrameCodec` 和部分握手驱动，各类 Transport/Endpoint 负责组合调用。TCP fallback 仍由具体 Transport 维护，Endpoint 仍可能参与握手生命周期。
+
+```mermaid
+flowchart TB
+    Socket["Socket"] --> T["RdmaTransport / UrmaTransport / UBShmTransport"]
+    T --> TCP["TcpTransport\nTCP fallback"]
+    T --> HS["HandshakeSession\n公共握手驱动"]
+    HS --> IO["HandshakeIO / FrameCodec"]
+    HS --> EP["RdmaEndpoint / UrmaEndpoint / UBShmEndpoint"]
+    EP --> EHS["Endpoint handshake callbacks\nBuildHello / ParseHello / Negotiate"]
+    EP --> DP["高速数据面\nQP / Jetty / UBRing"]
+    T --> FB["Transport fallback state"]
+    FB --> TCP
+```
+
+该方案可以先复用 frame 和 I/O 代码，改动较小；但握手生命周期仍然横跨 Transport 和 Endpoint，Endpoint 与 TCP 控制连接之间仍存在一定耦合。
+
+### 方案 B：Handshake 放到 Transport 上层，Endpoint 只负责数据面
+
+这是本次建议的方向：默认先建立 TCP 连接，客户端可以请求升级到 RDMA、URMA 或 UBSHM。握手、升级决策、fallback 和 active transport 选择全部由上层 Transport 负责。
+
+```mermaid
+flowchart TB
+    Socket["Socket"] --> UT["UpgradeTransport / NegotiatingTransport"]
+    UT --> TCP["TcpTransport\n默认控制面与 TCP 数据面"]
+    UT --> HS["HandshakeSession\n连接协商 / 版本 / ACK / fallback"]
+    HS --> IO["HandshakeIO + FrameCodec"]
+    UT --> PF["UpgradeProvider\n选择协议与 Endpoint factory"]
+    PF --> R["RdmaEndpoint\n仅高速数据面"]
+    PF --> U["UrmaEndpoint\n仅高速数据面"]
+    PF --> B["UBShmEndpoint\n仅高速数据面"]
+    R --> RD["QP / CQ / MR"]
+    U --> UD["Jetty / JFC / Segment"]
+    B --> BD["UBRing / Shared Memory"]
+    UT --> ST["TransportState\nTCP_ACTIVE / UPGRADING / HIGH_SPEED_ACTIVE"]
+    ST --> TCP
+    ST --> R
+    ST --> U
+    ST --> B
+```
+
+方案 B 中，Endpoint 不再执行 TCP fd 读写、magic 判断、握手 bthread 或 TCP fallback。它只向 Transport 提供资源准备、Hello payload、远端参数应用和数据面操作。
+
+### 两种方案的主要差异
+
+```mermaid
+flowchart LR
+    A["方案 A\nHandshake 与 Endpoint 组合"] --> A1["公共代码复用较快"]
+    A --> A2["Endpoint 仍参与连接控制"]
+    A --> A3["Fallback 状态分散"]
+    A --> A4["后续新增传输仍需接入 Endpoint 握手"]
+
+    B["方案 B\nHandshake 位于 Transport"] --> B1["TCP 是统一默认控制面"]
+    B --> B2["Endpoint 只负责高速数据面"]
+    B --> B3["Fallback 与 active path 统一"]
+    B --> B4["新增传输只需提供 Provider"]
+```
+
+## 4.2 方案 B 的连接升级时序
+
+### 客户端请求高速传输
+
+```mermaid
+sequenceDiagram
+    participant C as Client
+    participant T as UpgradeTransport
+    participant TCP as TcpTransport
+    participant H as HandshakeSession
+    participant E as High-speed Endpoint
+    participant S as Server Transport
+
+    C->>T: Connect()
+    T->>TCP: Establish TCP connection
+    TCP-->>T: TCP connected
+    T->>H: StartClient()
+    H->>TCP: Send high-speed Hello
+    TCP->>S: Hello over TCP
+    S->>S: Select RDMA / URMA / UBSHM provider
+    S-->>TCP: Remote Hello
+    TCP-->>H: Receive Remote Hello
+    H->>E: Parse remote parameters / prepare resources
+    E-->>H: Resource negotiation result
+    alt Upgrade succeeds
+        H->>TCP: Send enabled ACK
+        H->>T: NEGOTIATED
+        T->>E: Activate()
+        T-->>C: Connect done, high-speed active
+    else Upgrade unavailable or resource failure
+        H->>TCP: Send disabled ACK
+        H->>T: FALLBACK
+        T-->>C: Connect done, TCP active
+    end
+```
+
+### 服务端识别客户端请求
+
+```mermaid
+sequenceDiagram
+    participant TCP as TcpTransport
+    participant T as UpgradeTransport
+    participant H as HandshakeSession
+    participant E as Selected Endpoint
+    participant IM as InputMessenger
+
+    TCP->>T: TCP readable event
+    T->>T: Peek magic
+    alt Magic matches upgrade protocol
+        T->>H: Create protocol handshake
+        H->>T: Consume Hello frame
+        H->>E: Parse and negotiate resources
+        alt Negotiation succeeds
+            E-->>H: Ready
+            H->>T: Activate endpoint
+            T->>E: Future data events
+        else Negotiation fails
+            H->>T: Fallback to TCP
+            T->>IM: Continue normal TCP parsing
+        end
+    else Magic does not match
+        T->>T: Push back inspected bytes
+        T->>IM: Continue normal TCP parsing
+    end
+```
+
+## 5. 核心接口设计
+
+### 5.1 统一结果类型
+
+```cpp
+namespace brpc {
+namespace handshake {
+
+enum class Role {
+    CLIENT,
+    SERVER,
+};
+
+enum class Result {
+    NEGOTIATED,
+    FALLBACK,
+    NEED_MORE_DATA,
+    IO_ERROR,
+    PROTOCOL_ERROR,
+    RESOURCE_ERROR,
+};
+
+enum class Phase {
+    INIT,
+    HELLO_SEND,
+    HELLO_WAIT,
+    RESOURCE_NEGOTIATION,
+    ACK_SEND,
+    ACK_WAIT,
+    ESTABLISHED,
+    FALLBACK_TCP,
+    FAILED,
+};
+
+}  // namespace handshake
+}  // namespace brpc
+```
+
+这可以统一当前 RDMA 的 `RemoteHelloResult` 和 URMA 的 `int + bool negotiated`，也覆盖 UBSHM 的状态转换。
+
+### 5.2 字节流接口
+
+握手组件不能直接依赖 `Socket`，否则公共组件会被 brpc endpoint 的私有状态和不同的 server 解析方式绑死。
+
+建议提供两个方向的接口：
+
+```cpp
+class HandshakeIO {
+public:
+    virtual ~HandshakeIO() = default;
+
+    // Client 或握手 bthread 使用：必须读满 len 字节。
+    virtual Result ReadExact(void* data, size_t len) = 0;
+
+    // 必须写完全部数据。
+    virtual Result WriteAll(const void* data, size_t len) = 0;
+
+    // 将已经读取但不属于当前握手的数据放回 TCP 输入缓冲区。
+    virtual Result PushBack(const void* data, size_t len) = 0;
+};
+
+class HandshakeInput {
+public:
+    virtual ~HandshakeInput() = default;
+
+    // Server 的 InputMessenger 使用：只查看，不消费。
+    virtual size_t Size() const = 0;
+    virtual bool CopyTo(void* data, size_t len) const = 0;
+
+    // 仅在帧已经完整时消费。
+    virtual bool Consume(size_t len) = 0;
+};
+```
+
+实现方式：
+
+- client：把当前 `ReadFromFd/WriteToFd` 封装成 `SocketHandshakeIO`；
+- server：把 `butil::IOBuf` 封装成 `IOBufHandshakeInput`；
+- UBSHM 当前 server 也使用 fd 读取，可先使用 `SocketHandshakeIO`，后续再迁移到增量解析；
+- RDMA 的 `rdma_handshake_server.cpp` 可以直接使用 `HandshakeInput`。
+
+### 5.3 FrameCodec
+
+FrameCodec 只处理 framing，不理解 RDMA、URMA 或 UBSHM 的业务字段。
+
+```cpp
+struct FrameSpec {
+    const char* magic;
+    size_t magic_len;
+    size_t min_frame_len;
+    size_t max_frame_len;
+    enum LengthEncoding {
+        FIXED,
+        U16_TOTAL_LENGTH,
+        U32_BODY_LENGTH,
+    } length_encoding;
+};
+
+class FrameCodec {
+public:
+    static Result ReadMagic(HandshakeIO* io,
+                            const FrameSpec& spec,
+                            std::string* magic);
+
+    static Result ReadFrame(HandshakeIO* io,
+                            const FrameSpec& spec,
+                            std::string* frame);
+
+    static Result ParseBufferedFrame(HandshakeInput* input,
+                                      const FrameSpec& spec,
+                                      std::string* frame);
+
+    static Result DrainFrame(HandshakeIO* io,
+                             const FrameSpec& spec);
+};
+```
+
+三种协议可以配置为：
+
+| 传输 | 版本 | Magic | Framing |
+|---|---:|---|---|
+| RDMA | v2 | `RDMA` | U16，总长度 |
+| RDMA | v3 | `RDM3` | U32，body 长度 |
+| URMA | v2 | `URMA` | U16，总长度 |
+| URMA | v3 | `URM3` | U32，body 长度 |
+| UBSHM | v2 | `UB` | 固定长度 64 字节 |
+
+特别注意：`magic_len` 不能固定为 4。UBSHM 使用 2 字节 magic，因此公共组件必须以 `FrameSpec` 为准，而不能复用 RDMA 的 `HELLO_MAGIC_LEN`。
+
+### 5.4 协议适配器
+
+每个传输提供自己的协议适配器：
+
+```cpp
+class HandshakeProtocol {
+public:
+    virtual ~HandshakeProtocol() = default;
+
+    virtual int Version() const = 0;
+    virtual const FrameSpec& HelloFrameSpec() const = 0;
+
+    // 构造本地 Hello payload。
+    virtual Result BuildHello(std::string* out,
+                              bool negotiable) = 0;
+
+    // 校验并解析对端 Hello；只做协议层校验。
+    virtual Result ParseHello(const std::string& frame,
+                              std::shared_ptr<void>* parsed) = 0;
+
+    // 交给具体 endpoint 创建/导入高速资源。
+    virtual Result Negotiate(void* parsed) = 0;
+
+    // 构造和解析传输特有 ACK。
+    virtual Result BuildAck(bool enabled, std::string* out) = 0;
+    virtual Result ParseAck(const std::string& ack, bool* enabled) = 0;
+};
+```
+
+实际实现中不建议使用裸 `shared_ptr<void>`，更适合使用各协议自己的 `ParsedHello` 结构配合回调，或者让 `HandshakeDriver` 只传递 `std::string payload`，由 endpoint 在回调中解析。
+
+建议第一版采用回调方式，避免公共头文件包含协议专有类型：
+
+```cpp
+struct HandshakeCallbacks {
+    std::function<Result(std::string* hello)> build_hello;
+    std::function<Result(const std::string& hello)> parse_remote_hello;
+    std::function<Result(bool enabled, std::string* ack)> build_ack;
+    std::function<Result(const std::string& ack, bool* enabled)> parse_ack;
+    std::function<Result()> negotiate_resources;
+};
+```
+
+## 6. HandshakeDriver 状态机
+
+### 6.1 Client 流程
+
+```text
+INIT
+  -> build_hello
+  -> send_hello
+  -> receive_remote_hello
+  -> parse/validate
+  -> negotiate_resources
+  -> receive_remote_ack 或发送本地 ACK
+  -> ESTABLISHED
+```
+
+任一步骤发现对端不支持当前高速传输时：
+
+```text
+FALLBACK_TCP
+  -> 保留/回放未消费的 TCP 数据
+  -> 交给 InputMessenger/TcpTransport
+```
+
+### 6.2 Server 流程
+
+```text
+UNINIT
+  -> 读取 magic
+  -> 根据 magic/version 选择协议适配器
+  -> 读取完整 Hello
+  -> parse/validate
+  -> negotiate_resources
+  -> send local Hello
+  -> receive client ACK
+  -> ESTABLISHED 或 FALLBACK_TCP
+```
+
+server 解析必须保留 `NEED_MORE_DATA`：
+
+- RDMA 的 policy parser 可能多次收到 `IOBuf` 片段；
+- 后续 URMA/UBSHM 如果接入统一 server parser，也需要同样行为；
+- 未读完整时不得消费输入缓冲区。
+
+### 6.3 公共驱动不负责的动作
+
+`HandshakeDriver` 在协议成功后只调用回调，不直接操作资源：
+
+- RDMA：回调中执行 `AllocateResources/BringUpQp`；
+- URMA：回调中执行 `AllocateResources/ImportPeer`；
+- UBSHM：回调中执行 `AllocateClientResources/AllocateServerResources`。
+
+这样可以保证握手公共组件不依赖三种数据面 API。
+
+## 7. 三种传输的适配方式
+
+### 7.1 RDMAAdapter
+
+保留：
+
+- `ParsedHello`；
+- `HelloMessage` 序列化和反序列化；
+- RDMA v2/v3 protobuf；
+- ECE 校验和 QP 参数处理；
+- `BringUpQp`；
+- RDMA 专属 fallback hello。
+
+迁移后由 adapter 提供：
+
+```text
+BuildHello -> FillLocalRdmaHello
+ParseHello -> ValidRdmaHello + TranslateHello
+Negotiate  -> ApplyRemoteHello + BringUpQp
+BuildAck   -> RDMA ACK
+```
+
+### 7.2 URMAAdapter
+
+保留：
+
+- EID/UASID/Jetty/segment/token 字段；
+- URMA v2/v3 protobuf；
+- `ValidHello`；
+- `ImportPeer`；
+- URMA bonding 相关逻辑。
+
+迁移后由 adapter 提供：
+
+```text
+BuildHello -> FillLocalHelloV2/FillLocalHelloV3
+ParseHello -> ValidHello + ParsedHello
+Negotiate  -> ApplyRemoteHello + ImportPeer
+BuildAck   -> URMA ACK
+```
+
+### 7.3 UBSHMAdapter
+
+保留：
+
+- `HelloMessage`；
+- `HelloMessage::Serialize/Deserialize`；
+- `HelloNegotiationValid`；
+- shared memory 名称和长度校验；
+- `AllocateClientResources/AllocateServerResources`；
+- `UB_OK` ACK bit。
+
+迁移后由 adapter 提供：
+
+```text
+BuildHello -> 填充 UB HelloMessage
+ParseHello -> 校验 hello_ver/impl_ver/msg_len
+Negotiate  -> 创建或映射 SHM/ring
+BuildAck   -> 4 字节 UB flags
+```
+
+UBSHM 是最适合优先迁移的实现，因为它只有固定长度 v2 协议，不涉及 protobuf 和多版本 frame dispatch。
+
+## 8. 与现有 Endpoint 的关系
+
+不建议让 `RdmaEndpoint`、`UrmaEndpoint`、`UBShmEndpoint` 继承一个包含大量虚函数的“大 Endpoint 基类”。更合适的方式是组合：
+
+```cpp
+class RdmaEndpoint {
+    handshake::HandshakeDriver _handshake;
+    RdmaHandshakeAdapter _handshake_adapter;
+};
+
+class UrmaEndpoint {
+    handshake::HandshakeDriver _handshake;
+    UrmaHandshakeAdapter _handshake_adapter;
+};
+
+class UBShmEndpoint {
+    handshake::HandshakeDriver _handshake;
+    UBShmHandshakeAdapter _handshake_adapter;
+};
+```
+
+Endpoint 仍然拥有：
+
+- Socket；
+- transport-specific resource；
+- endpoint state 的业务动作；
+- data path；
+- InputMessenger 回调；
+- transport-specific error handling。
+
+公共 driver 只拥有握手阶段和 protocol callback，不拥有 endpoint 生命周期。
+
+## 9. 兼容性和安全约束
+
+### 9.1 Wire compatibility
+
+重构前后必须保持：
+
+- magic 不变；
+- v2/v3 版本号不变；
+- 长度字段的字节序和语义不变；
+- ACK 长度和 bit 定义不变；
+- fallback hello 的无效字段规则不变；
+- RDMA/URMA/UBSHM 之间不能误识别 magic。
+
+### 9.2 长度校验
+
+FrameCodec 必须统一执行：
+
+- 最小帧长度检查；
+- 最大帧长度限制；
+- 整数溢出检查；
+- 长度字段是否包含 magic 的明确配置；
+- protobuf body 长度限制；
+- 固定长度协议的精确长度检查。
+
+### 9.3 fallback 数据处理
+
+当 magic 不匹配时：
+
+- client 侧按现有协议处理错误或回退；
+- server 侧必须将已经读取的 magic 放回 `_read_buf`，再交给 TCP parser；
+- 任何已经确认属于高速协议的完整帧，不能直接交给普通 TCP parser。
+
+### 9.4 资源失败
+
+协议格式正确不代表高速传输一定可用：
+
+```text
+Hello valid
+    -> resource allocation/import failed
+    -> send non-negotiable hello or disabled ACK
+    -> fallback TCP
+```
+
+因此 `ParseHello` 和 `Negotiate` 必须保持两个独立步骤。
+
+## 10. 测试方案
+
+### 10.1 公共组件单元测试
+
+覆盖：
+
+- magic 长度为 2 和 4；
+- fixed/U16/U32 三种 framing；
+- 半包读取；
+- 多余数据 drain；
+- 最大长度和最小长度；
+- 长度字段溢出；
+- magic 不匹配并 push-back；
+- `NEED_MORE_DATA` 时不消费输入 buffer；
+- IO error、EOF、超时。
+
+### 10.2 协议适配器测试
+
+分别测试：
+
+- RDMA v2/v3 hello；
+- URMA v2/v3 hello；
+- UBSHM v2 hello；
+- invalid hello fallback；
+- ACK enabled/disabled；
+- resource negotiation failure。
+
+### 10.3 兼容性测试
+
+至少保留以下组合：
+
+| Client | Server | 预期 |
+|---|---|---|
+| RDMA v2 | RDMA v2 | RDMA |
+| RDMA v3 | RDMA v3 | RDMA |
+| URMA v2 | URMA v2 | URMA |
+| URMA v3 | URMA v3 | URMA |
+| UBSHM | UBSHM | UBSHM |
+| 高速 client | TCP server | TCP fallback |
+| TCP client | 高速 server | TCP fallback |
+| 高速资源失败 | 高速对端 | TCP fallback |
+
+## 11. 分阶段实施计划
+
+### Phase 0：建立行为基线
+
+- 为 RDMA、URMA、UBSHM 现有 handshake 增加或补齐单元测试；
+- 固化现有 wire format 样例；
+- 记录状态转换和 fallback 行为。
+
+### Phase 1：抽取公共 I/O 和 framing
+
+- 新增 `src/brpc/handshake/handshake_io.*`；
+- 新增 `src/brpc/handshake/handshake_frame.*`；
+- 先迁移 UBSHM 固定长度握手；
+- 再迁移 URMA v2；
+- 最后迁移 RDMA v2/v3。
+
+### Phase 2：抽取公共 driver
+
+- 引入统一 `Result/Phase`；
+- 将 client/server 的握手阶段迁移到 `HandshakeDriver`；
+- 保留各 endpoint 的资源协商回调；
+- 统一 fallback 和错误处理。
+
+### Phase 3：清理旧实现
+
+- 删除三套重复的 `ReadFromFd/WriteToFd` 握手代码；
+- 删除可替代的 magic/length 解析代码；
+- 保留各协议的 wire codec 和资源适配器；
+- 更新 CMake、Bazel 和相关测试目标。
+
+## 12. 主要风险和规避方式
+
+### 风险一：公共抽象过度绑定 Socket
+
+规避：公共组件只使用 `HandshakeIO`/`HandshakeInput`，不直接包含 `brpc/socket.h`。
+
+### 风险二：混淆不同长度字段语义
+
+RDMA/URMA/UBSHM 的长度字段并不完全相同。规避：使用 `FrameSpec::LengthEncoding`，并在每个协议 adapter 中明确配置。
+
+### 风险三：server 增量解析行为改变
+
+规避：公共 `ParseBufferedFrame` 在完整帧可用前只返回 `NEED_MORE_DATA`，不消费任何数据。
+
+### 风险四：握手成功后资源失败被误认为协议失败
+
+规避：将 `ParseHello` 与 `Negotiate` 分离，资源失败统一转换成可配置的 fallback 行为。
+
+### 风险五：UBSHM 的 2 字节 magic 被 4 字节假设破坏
+
+规避：所有 magic 操作都依赖 `FrameSpec.magic_len`，禁止公共代码写死 4。
+
+## 13. 结论
+
+建议抽取的公共组件边界是：
+
+```text
+公共：TCP 握手 I/O、frame framing、magic/length、增量解析、状态驱动、ACK/fallback 结果
+私有：Hello payload、版本语义、资源协商、QP/Jetty/SHM 创建、数据面 completion
+```
+
+实施上优先从 UBSHM 固定长度握手开始，再迁移 URMA 和 RDMA。这样可以先验证公共组件的接口，不需要一开始处理 RDMA/URMA 的 protobuf、多版本和复杂资源依赖。

From f1ea19fc17456e92270272db81ebdc566d034a06 Mon Sep 17 00:00:00 2001
From: Gzure <740684863@qq.com>
Date: Mon, 17 Aug 2026 15:30:45 +0800
Subject: [PATCH 02/11] Move high-speed handshakes to transports

---
 docs/cn/handshake_common_design.md         |  52 ++-
 src/brpc/rdma/rdma_endpoint.cpp            | 477 +--------------------
 src/brpc/rdma/rdma_endpoint.h              | 110 ++---
 src/brpc/rdma/rdma_handshake.cpp           |  53 +--
 src/brpc/rdma/rdma_handshake.h             |  37 +-
 src/brpc/rdma/rdma_handshake_server.cpp    |  13 +-
 src/brpc/rdma/rdma_handshake_server.h      |   8 +-
 src/brpc/rdma_transport.cpp                | 317 +++++++++++++-
 src/brpc/rdma_transport.h                  |  32 +-
 src/brpc/transport_handshake.cpp           | 156 +++++++
 src/brpc/transport_handshake.h             | 108 +++++
 src/brpc/ubshm/ub_endpoint.cpp             | 241 +++++------
 src/brpc/ubshm/ub_endpoint.h               |  50 +--
 src/brpc/ubshm_transport.cpp               |  10 +-
 src/brpc/ubshm_transport.h                 |  25 +-
 test/brpc_transport_handshake_unittest.cpp |  46 ++
 16 files changed, 951 insertions(+), 784 deletions(-)
 create mode 100644 src/brpc/transport_handshake.cpp
 create mode 100644 src/brpc/transport_handshake.h
 create mode 100644 test/brpc_transport_handshake_unittest.cpp

diff --git a/docs/cn/handshake_common_design.md b/docs/cn/handshake_common_design.md
index 3a79580d74..15e680eaed 100644
--- a/docs/cn/handshake_common_design.md
+++ b/docs/cn/handshake_common_design.md
@@ -724,7 +724,7 @@ Hello valid
 
 ### 风险一：公共抽象过度绑定 Socket
 
-规避：公共组件只使用 `HandshakeIO`/`HandshakeInput`，不直接包含 `brpc/socket.h`。
+规避：状态发布和协议 adapter 不依赖 Endpoint；仅最外层 `SocketHandshakeIO` 适配器持有非 owning `Socket*`，集中封装 fd 等待与读写。后续如需脱离 brpc Socket 测试，可在该适配器之下再拆纯虚 `HandshakeIO`。
 
 ### 风险二：混淆不同长度字段语义
 
@@ -751,4 +751,52 @@ RDMA/URMA/UBSHM 的长度字段并不完全相同。规避：使用 `FrameSpec::
 私有：Hello payload、版本语义、资源协商、QP/Jetty/SHM 创建、数据面 completion
 ```
 
-实施上优先从 UBSHM 固定长度握手开始，再迁移 URMA 和 RDMA。这样可以先验证公共组件的接口，不需要一开始处理 RDMA/URMA 的 protobuf、多版本和复杂资源依赖。
+实施上以当前 RDMA 握手状态机为基线：先保留 #3350 已接入的标准 server 协议解析流程，再迁移 UBSHM，最后在 URMA 分支重新基于公共接口适配。这样可以直接继承已经过社区修复和测试的 fallback 语义。
+
+## 14. 方案 B 第一版实现约束
+
+第一版新增 `src/brpc/transport_handshake.*`，由 Transport 持有握手状态和 TCP 控制面 I/O：
+
+```mermaid
+flowchart LR
+    S["Socket"] --> T["RdmaTransport / UBShmTransport"]
+    T --> TCP["TcpTransport\n默认 active / fallback"]
+    T --> H["SocketHandshakeIO\nphase + ReadExact + WriteAll"]
+    T --> E["Endpoint\n资源准备与数据面"]
+    H -->|"NEGOTIATED"| E
+    H -->|"FALLBACK_TCP"| TCP
+    E -. "不再持有 handshake state、read butex 或 TCP fd I/O" .-> T
+```
+
+具体边界如下：
+
+- `RdmaTransport` 持有 client/server 状态机；server 继续通过 #3350 引入的 bRPC 标准协议解析流程执行增量握手。
+- `UBShmTransport` 持有 client/server 状态机；`UBShmEndpoint` 只保留 SHM/ring 资源和数据面操作。后续可把 UBSHM server 固定帧接入同一标准 parser。
+- `RdmaHandshake` 仍负责 v2/v3 wire codec，但 TCP 读写改为依赖 Transport 提供的公共 `SocketHandshakeIO`，不再调用 `RdmaEndpoint::ReadFromFd/WriteToFd`。
+- origin/master 暂无受版本控制的 URMA Transport；URMA 合入或 rebase 后只需按相同边界注入 `SocketHandshakeIO` 并把状态机移到 `UrmaTransport`，不应提交本地未跟踪的旧实现。
+
+### 14.1 必须继承的修复语义
+
+| 修复 | 公共约束 | 第一版落点 |
+|---|---|---|
+| #3347 | fallback 状态必须原子发布，事件线程用 acquire 读取 | `SocketHandshakeIO::PublishFallback/phase` |
+| #3406 | 必须先发布 Transport 的 TCP active/off 状态，再 release 发布 `FALLBACK_TCP` | `PublishFallback` 回调先执行，随后 release store |
+| #3424 | 高速资源准备失败是可降级错误；清理部分资源并保持 TCP 可用 | RDMA 保留事务式 `AllocateResources`；UBSHM 失败路径补充资源清理 |
+| #3425 | CQ re-arm 后同时补 poll send/recv CQ | 保留在 RDMA Endpoint 数据面，不移入握手组件 |
+| #3427 | 外部 Bazel workspace 下生成规则不能依赖主仓布局 | 公共实现不新增 proto；源码通过现有递归 glob 收录 |
+
+### 14.2 状态发布规则
+
+成功升级和回退只能由 Transport 发布：
+
+```cpp
+// Fallback: publish TCP selection first, then release-publish terminal phase.
+handshake.PublishFallback([transport]() {
+    transport->SetHighSpeedOff();
+});
+
+// Success: all endpoint resources are ready before publishing ESTABLISHED.
+handshake.MarkEstablished();
+```
+
+事件线程必须通过 acquire load 读取 phase。看到 `FALLBACK_TCP` 后可以直接恢复 `InputMessenger`；看到 `ESTABLISHED` 后才允许发送和接收高速数据。`UNKNOWN/NEGOTIATING` 状态不得路由到 Endpoint 数据面。
diff --git a/src/brpc/rdma/rdma_endpoint.cpp b/src/brpc/rdma/rdma_endpoint.cpp
index e2ce2e0c1b..f8341d3e0b 100644
--- a/src/brpc/rdma/rdma_endpoint.cpp
+++ b/src/brpc/rdma/rdma_endpoint.cpp
@@ -110,9 +110,12 @@ RdmaResource::~RdmaResource() {
 }
 
 RdmaEndpoint::RdmaEndpoint(Socket* s)
+#ifdef UNIT_TEST
+    : _state(s)
+    , _socket(s)
+#else
     : _socket(s)
-    , _state(UNINIT)
-    , _handshake_version(0)
+#endif
     , _resource(NULL)
     , _send_cq_events(0)
     , _recv_cq_events(0)
@@ -146,19 +149,23 @@ RdmaEndpoint::RdmaEndpoint(Socket* s)
     if (_rq_size > MAX_QP_SIZE) {
         _rq_size = MAX_QP_SIZE;
     }
-    _read_butex = bthread::butex_create_checked<butil::atomic<int> >();
 }
 
+#ifdef UNIT_TEST
+RdmaEndpoint::StateView::operator State() const {
+    const RdmaTransport* transport =
+        static_cast<const RdmaTransport*>(_socket->_transport.get());
+    return static_cast<State>(transport->handshake_phase());
+}
+#endif
+
 RdmaEndpoint::~RdmaEndpoint() {
     Reset();
-    bthread::butex_destroy(_read_butex);
 }
 
 void RdmaEndpoint::Reset() {
     DeallocateResources();
 
-    _state.store(UNINIT, butil::memory_order_relaxed);
-    _handshake_version = 0;
     _outgoing_ece.reset();
     _resource = NULL;
     _send_cq_events = 0;
@@ -183,214 +190,6 @@ void RdmaEndpoint::Reset() {
     _new_rq_wrs.store(0, butil::memory_order_relaxed);
 }
 
-void RdmaConnect::StartConnect(const Socket* socket,
-                               void (*done)(int err, void* data),
-                               void* data) {
-    auto* rdma_transport = static_cast<RdmaTransport*>(socket->_transport.get());
-    CHECK(rdma_transport->_rdma_ep != NULL);
-    SocketUniquePtr s;
-    if (Socket::Address(socket->id(), &s) != 0) {
-        return;
-    }
-    if (!IsRdmaAvailable()) {
-        rdma_transport->_rdma_state = RdmaTransport::RDMA_OFF;
-        rdma_transport->_rdma_ep->_state.store(
-            RdmaEndpoint::FALLBACK_TCP, butil::memory_order_release);
-        done(0, data);
-        return;
-    }
-    _done = done;
-    _data = data;
-    bthread_t tid;
-    bthread_attr_t attr = BTHREAD_ATTR_NORMAL;
-    bthread_attr_set_name(&attr, "RdmaProcessHandshakeAtClient");
-    if (bthread_start_background(&tid, &attr,
-                                 RdmaEndpoint::ProcessHandshakeAtClient,
-                                 rdma_transport->_rdma_ep) < 0) {
-        LOG(FATAL) << "Fail to start handshake bthread";
-        Run();
-    } else {
-        s.release();
-    }
-}
-
-void RdmaConnect::StopConnect(Socket* socket) { }
-
-void RdmaConnect::Run() {
-    _done(errno, _data);
-}
-
-void RdmaEndpoint::OnNewDataFromTcp(Socket* m) {
-    auto* rdma_transport = static_cast<RdmaTransport*>(m->_transport.get());
-    RdmaEndpoint* ep = rdma_transport->GetRdmaEp();
-    CHECK(ep != NULL);
-
-    int progress = Socket::PROGRESS_INIT;
-    while (true) {
-        // Pair with release stores of FALLBACK_TCP so RDMA_OFF is visible
-        // before normal TCP message processing starts.
-        const State state = ep->_state.load(butil::memory_order_acquire);
-        if (state == UNINIT) {
-            // The connection may be closed or reset before the client starts
-            // handshake. This will be handled by client handshake. Ignore here.
-        } else if (state < ESTABLISHED) {  // during handshake
-            ep->_read_butex->fetch_add(1, butil::memory_order_release);
-            bthread::butex_wake(ep->_read_butex);
-        } else if (state == FALLBACK_TCP){  // handshake finishes
-            InputMessenger::OnNewMessages(m);
-            return;
-        } else if (state == ESTABLISHED) {
-            uint8_t tmp;
-            ssize_t nr = read(ep->_socket->fd(), &tmp, 1);
-            if (nr == 0) {
-                ep->_socket->SetEOF();
-                return;
-            }
-            if (nr > 0) {
-                LOG(WARNING) << "Read unexpected data from " << ep->_socket;
-                ep->_socket->SetFailed(EPROTO, "Read unexpected data from %s",
-                                       ep->_socket->description().c_str());
-                return;
-            }
-
-            if (errno != EAGAIN) {
-                const int saved_errno = errno;
-                PLOG(WARNING) << "Fail to read from " << ep->_socket;
-                ep->_socket->SetFailed(saved_errno, "Fail to read from %s: %s",
-                                       ep->_socket->description().c_str(),
-                                       berror(saved_errno));
-            }
-        }
-        if (!m->MoreReadEvents(&progress)) {
-            break;
-        }
-    }
-}
-
-static const int WAIT_TIMEOUT_MS = 50;
-
-// Drive an EAGAIN-aware read loop to completion (exactly `len` bytes).
-// `read_once(offset, remaining)` performs ONE underlying read attempt:
-//   returns > 0  : number of bytes consumed (added to running total);
-//   returns = 0  : end-of-stream (the loop fails with EEOF);
-//   returns < 0  : errno set; EAGAIN is handled here via butex_wait,
-//                   any other errno bubbles up.
-// `offset` is bytes already received in THIS call (initially 0); the
-// callable uses it to choose the next write target (e.g. `(char*)buf
-// + offset`). Callables that don't need offset (e.g. IOPortal append)
-// can ignore it.
-//
-// Centralizes the EAGAIN/butex/EOF loop so the two ReadFromFd
-// overloads below stay one-liners; any future read source (memory-
-// mapped, scatter-vector, etc.) can plug in by passing its own
-// `read_once`.
-template <class ReadOnce>
-static int ReadFromFdLoop(butil::atomic<int>* read_butex,
-                          size_t len, ReadOnce&& read_once) {
-    size_t received = 0;
-    while (received < len) {
-        const int expected_val = read_butex->load(butil::memory_order_acquire);
-        const timespec duetime = butil::milliseconds_from_now(WAIT_TIMEOUT_MS);
-        ssize_t nr = read_once(received, len - received);
-        if (nr < 0) {
-            if (errno == EAGAIN) {
-                if (bthread::butex_wait(read_butex, expected_val, &duetime) < 0) {
-                    if (errno != EWOULDBLOCK && errno != ETIMEDOUT) {
-                        return -1;
-                    }
-                }
-            } else {
-                return -1;
-            }
-        } else if (nr == 0) {  // Got EOF
-            errno = EEOF;
-            return -1;
-        } else {
-            received += nr;
-        }
-    }
-    return 0;
-}
-
-int RdmaEndpoint::ReadFromFd(void* data, size_t len) {
-    CHECK(data != NULL);
-    const int fd = _socket->fd();
-    return ReadFromFdLoop(_read_butex, len,
-        [data, fd](size_t offset, size_t remaining) {
-            return read(fd, (uint8_t*)data + offset, remaining);
-        });
-}
-
-int RdmaEndpoint::ReadFromFd(butil::IOPortal* data, size_t len) {
-    CHECK(data != NULL);
-    const int fd = _socket->fd();
-    return ReadFromFdLoop(_read_butex, len,
-        [data, fd](size_t /*offset*/, size_t remaining) {
-            return data->append_from_file_descriptor(fd, remaining);
-        });
-}
-
-// Drive an EAGAIN-aware write loop to completion (exactly `len` bytes).
-//
-// `write_once(offset, remaining)` performs ONE underlying write attempt:
-//   - returns >= 0 : number of bytes consumed (added to running total);
-//   - returns < 0  : errno set; EAGAIN triggers `wait_writable(duetime)`,
-//                   any other errno bubbles up.
-// `offset` is bytes already written in THIS call (initially 0); the
-// callable uses it to choose the next read source (e.g. `(char*)buf
-// + offset`). Callables that drain a self-tracking sink (e.g.
-// IOBuf::cut_into_file_descriptor) can ignore both args.
-//
-// `wait_writable(duetime)` is invoked on EAGAIN to park until the fd
-// becomes writable again. It returns 0 on wake-up (or ETIMEDOUT),
-// non-zero on hard failure.
-template <class WriteOnce, class WaitWritable>
-static int WriteToFdLoop(size_t len, WriteOnce&& write_once, WaitWritable&& wait_writable) {
-    size_t written = 0;
-    while (written < len) {
-        const timespec duetime = butil::milliseconds_from_now(WAIT_TIMEOUT_MS);
-        ssize_t nw = write_once(written, len - written);
-        if (nw >= 0) {
-            written += nw;
-            continue;
-        }
-
-        if (errno != EAGAIN) {
-            return -1;
-        }
-        if (!wait_writable(&duetime)) {
-            return -1;
-        }
-    }
-    return 0;
-}
-
-int RdmaEndpoint::WriteToFd(void* data, size_t len) {
-    CHECK(data != NULL);
-    Socket* s = _socket;
-    const int fd = s->fd();
-    return WriteToFdLoop(len,
-        [data, fd](size_t offset, size_t remaining) {
-            return write(fd, (uint8_t*)data + offset, remaining);
-        },
-        [s, fd](const timespec* duetime) {
-            return s->WaitEpollOut(fd, true, duetime) == 0 || errno == ETIMEDOUT;
-        });
-}
-
-int RdmaEndpoint::WriteToFd(butil::IOBuf* data) {
-    CHECK(data != NULL);
-    Socket* s = _socket;
-    const int fd = s->fd();
-    return WriteToFdLoop(data->size(),
-        [data, fd](size_t /*offset*/, size_t /*remaining*/) {
-            return data->cut_into_file_descriptor(fd);
-        },
-        [s, fd](const timespec* duetime) {
-            return s->WaitEpollOut(fd, true, duetime) == 0 || errno == ETIMEDOUT;
-        });
-}
-
 void RdmaEndpoint::ApplyRemoteHello(const ParsedHello& remote) {
     _remote_recv_block_size = remote.block_size;
     _local_window_capacity = std::min(_sq_size, remote.rq_size) - RESERVED_WR_NUM;
@@ -418,233 +217,6 @@ void RdmaEndpoint::ApplyRemoteHello(const ParsedHello& remote) {
 //     |
 //     v
 //   ESTABLISHED / FALLBACK_TCP
-void* RdmaEndpoint::ProcessHandshakeAtClient(void* arg) {
-    auto ep = static_cast<RdmaEndpoint*>(arg);
-    SocketUniquePtr s(ep->_socket);
-    RdmaConnect::RunGuard rg((RdmaConnect*)s->_app_connect.get());
-    auto rdma_transport = static_cast<RdmaTransport*>(s->_transport.get());
-
-    LOG_IF(INFO, FLAGS_rdma_trace_verbose)
-        << "Start handshake on " << s->description();
-
-    std::unique_ptr<RdmaHandshake> handshake = CreateClientHandshake(ep);
-    CHECK(handshake != NULL);
-    ep->_handshake_version = handshake->ProtocolVersion();
-
-    // First initialize CQ and QP resources.
-    ep->_state.store(C_ALLOC_QPCQ, butil::memory_order_relaxed);
-    if (ep->AllocateResources() < 0) {
-        PLOG(WARNING) << "Fail to allocate rdma resources, fallback to tcp:"
-                      << s->description();
-        errno = 0;
-        rdma_transport->_rdma_state = RdmaTransport::RDMA_OFF;
-        ep->_state.store(FALLBACK_TCP, butil::memory_order_release);
-        return NULL;
-    }
-
-    // Send hello message to server
-    ep->_state.store(C_HELLO_SEND, butil::memory_order_relaxed);
-    if (handshake->SendLocalHello() < 0) {
-        int saved_errno = errno;
-        PLOG(WARNING) << "Fail to send hello message to server:"
-                      << s->description();
-        s->SetFailed(saved_errno, "Fail to complete rdma handshake from %s: %s",
-                     s->description().c_str(), berror(saved_errno));
-        ep->_state.store(FAILED, butil::memory_order_relaxed);
-        return NULL;
-    }
-
-    // Receive and parse remote hello.
-    ep->_state.store(C_HELLO_WAIT, butil::memory_order_relaxed);
-    ParsedHello remote{};
-    const RemoteHelloResult r = handshake->ReceiveAndParseRemoteHello(&remote);
-    if (r == RemoteHelloResult::ERROR) {
-        int saved_errno = errno;
-        PLOG(WARNING) << "Fail to receive hello from server:"
-                      << s->description();
-        s->SetFailed(saved_errno, "Fail to complete rdma handshake from %s: %s",
-                     s->description().c_str(), berror(saved_errno));
-        ep->_state.store(FAILED, butil::memory_order_relaxed);
-        return NULL;
-    }
-
-    if (r != RemoteHelloResult::NEGOTIATED) {
-        LOG(WARNING) << "Fail to negotiate with server, fallback to tcp:"
-                     << s->description();
-        rdma_transport->_rdma_state = RdmaTransport::RDMA_OFF;
-    } else {
-        ep->ApplyRemoteHello(remote);
-        ep->_state.store(C_BRINGUP_QP, butil::memory_order_relaxed);
-        if (ep->BringUpQp(remote, /*is_server=*/false) < 0) {
-            LOG(WARNING) << "Fail to bringup QP, fallback to tcp:"
-                         << s->description();
-            rdma_transport->_rdma_state = RdmaTransport::RDMA_OFF;
-        } else {
-            rdma_transport->_rdma_state = RdmaTransport::RDMA_ON;
-        }
-    }
-
-    // Send ACK message to server
-    ep->_state.store(C_ACK_SEND, butil::memory_order_relaxed);
-    bool rdma_on = rdma_transport->_rdma_state == RdmaTransport::RDMA_ON;
-    uint32_t flags = rdma_on ? HELLO_ACK_RDMA_OK : 0;
-    uint32_t flags_be = butil::HostToNet32(flags);
-    if (ep->WriteToFd(&flags_be, HELLO_ACK_LEN) < 0) {
-        int saved_errno = errno;
-        PLOG(WARNING) << "Fail to send Ack Message to server:"
-                      << s->description();
-        s->SetFailed(saved_errno, "Fail to complete rdma handshake from %s: %s",
-                     s->description().c_str(), berror(saved_errno));
-        ep->_state.store(FAILED, butil::memory_order_relaxed);
-        return NULL;
-    }
-
-    if (rdma_transport->_rdma_state == RdmaTransport::RDMA_ON) {
-        ep->_state.store(ESTABLISHED, butil::memory_order_relaxed);
-        LOG_IF(INFO, FLAGS_rdma_trace_verbose)
-            << "Client handshake ends (use rdma v" << ep->_handshake_version
-            << ") on " << s->description();
-    } else {
-        ep->_state.store(FALLBACK_TCP, butil::memory_order_release);
-        LOG_IF(INFO, FLAGS_rdma_trace_verbose)
-            << "Client handshake ends (use tcp) on " << s->description();
-    }
-
-    errno = 0;
-
-    return NULL;
-}
-
-// Server-side handshake entry: the state machine.
-//
-//   S_HELLO_WAIT  (read magic + dispatch + hs->ReceiveAndParseRemoteHello)
-//     |
-//     v
-//   [negotiation: ApplyRemoteHello + S_ALLOC_QPCQ + S_BRINGUP_QP]
-//     |
-//     v
-//   S_HELLO_SEND  (hs->SendLocalHello)
-//     |
-//     v
-//   S_ACK_WAIT
-//     |
-//     v
-//   ESTABLISHED / FALLBACK_TCP
-ParseResult RdmaEndpoint::ExecuteServerHandshake(butil::IOBuf* source, Socket* s) {
-    RdmaTransport* rdma_transport = static_cast<RdmaTransport*>(s->_transport.get());
-    RdmaEndpoint* ep = rdma_transport->_rdma_ep;
-    CHECK(ep != NULL);
-
-    if (s->parsing_context() == NULL) {
-        // Phase 1: read the client hello, negotiate, reply server hello.
-        if (source->size() < HELLO_MAGIC_LEN) {
-            return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
-        }
-        uint8_t magic[HELLO_MAGIC_LEN];
-        CHECK_EQ(source->copy_to(magic, HELLO_MAGIC_LEN), HELLO_MAGIC_LEN);
-
-        // Pick the version-specific server handshake from the peeked magic (the
-        // magic is NOT consumed; ReceiveAndParseRemoteHello() reads it again
-        // from `source`).
-        std::unique_ptr<RdmaHandshake> hs = CreateServerHandshakeByMagic(ep, source, magic);
-        if (hs == NULL) {
-            return MakeParseError(PARSE_ERROR_TRY_OTHERS);
-        }
-        ep->_handshake_version = hs->ProtocolVersion();
-        ep->_state.store(S_HELLO_WAIT, butil::memory_order_relaxed);
-
-        ParsedHello remote{};
-        const RemoteHelloResult r = hs->ReceiveAndParseRemoteHello(&remote);
-        if (r == RemoteHelloResult::NEED_MORE) {
-            return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
-        }
-        if (r == RemoteHelloResult::ERROR) {
-            ep->_state.store(FAILED, butil::memory_order_relaxed);
-            return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
-        }
-
-        // Negotiate + allocate resources.
-        bool negotiated = r == RemoteHelloResult::NEGOTIATED;
-        if (negotiated) {
-            ep->ApplyRemoteHello(remote);
-            ep->_state.store(S_ALLOC_QPCQ, butil::memory_order_relaxed);
-            if (ep->AllocateResources() < 0) {
-                PLOG(WARNING) << "Fail to allocate rdma resources, fallback to tcp:"
-                              << s->description();
-                negotiated = false;
-            } else {
-                ep->_state.store(S_BRINGUP_QP, butil::memory_order_relaxed);
-                if (ep->BringUpQp(remote, /*is_server=*/true) < 0) {
-                    LOG(WARNING) << "Fail to bringup QP, fallback to tcp:"
-                                 << s->description();
-                    negotiated = false;
-                }
-            }
-        }
-        if (!negotiated) {
-            rdma_transport->_rdma_state = RdmaTransport::RDMA_OFF;
-        }
-
-        // Reply the server hello.
-        // Emits a real hello when _rdma_state != RDMA_OFF;
-        // an un-negotiable one otherwise.
-        ep->_state.store(S_HELLO_SEND, butil::memory_order_relaxed);
-        if (hs->SendLocalHello() < 0) {
-            PLOG(WARNING) << "Fail to send server hello to " << s->description();
-            ep->_state.store(FAILED, butil::memory_order_relaxed);
-            return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
-        }
-
-        // Enter the wait-ACK phase. Whether negotiation succeeded is already
-        // recorded in rdma_transport->_rdma_state (RDMA_OFF iff negotiation
-        // failed), so the context itself needs no extra flag.
-        s->reset_parsing_context(ServerHandshakeContext::Create());
-        ep->_state.store(S_ACK_WAIT, butil::memory_order_relaxed);
-        return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
-    }
-
-    // Phase 2: drain the 4B ACK and finalize.
-    if (source->size() < HELLO_ACK_LEN) {
-        return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
-    }
-    if (source->size() > HELLO_ACK_LEN) {
-        LOG(WARNING) << "Too many bytes in handshake ACK, drop connection: "
-                     << s->description();
-        ep->_state.store(FAILED, butil::memory_order_relaxed);
-        s->reset_parsing_context(NULL);
-        return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
-    }
-
-    uint32_t flags_be = 0;
-    CHECK_EQ(source->cutn(&flags_be, HELLO_ACK_LEN), HELLO_ACK_LEN);
-    uint32_t flags = butil::NetToHost32(flags_be);
-    bool client_ack_ok = (flags & HELLO_ACK_RDMA_OK) != 0;
-    if (!client_ack_ok) {
-        LOG_IF(INFO, FLAGS_rdma_trace_verbose)
-            << "Server handshake ends (use tcp) on " << s->description();
-        rdma_transport->_rdma_state = RdmaTransport::RDMA_OFF;
-        ep->_state.store(FALLBACK_TCP, butil::memory_order_release);
-        s->reset_parsing_context(NULL);
-        return MakeParseError(PARSE_ERROR_TRY_OTHERS);
-    }
-
-    if (rdma_transport->_rdma_state == RdmaTransport::RDMA_OFF) {
-        LOG(WARNING) << "Client wants RDMA in ACK but server fell back: "
-                     << s->description();
-        ep->_state.store(FAILED, butil::memory_order_relaxed);
-        s->reset_parsing_context(NULL);
-        return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
-    }
-
-    LOG_IF(INFO, FLAGS_rdma_trace_verbose)
-        << "Server handshake ends (use rdma v" << ep->_handshake_version
-        << ") on " << s->description();
-    rdma_transport->_rdma_state = RdmaTransport::RDMA_ON;
-    ep->_state.store(ESTABLISHED, butil::memory_order_relaxed);
-    s->reset_parsing_context(NULL);
-    return MakeParseError(PARSE_ERROR_TRY_OTHERS);
-}
-
 bool RdmaEndpoint::IsWritable() const {
     if (BAIDU_UNLIKELY(g_skip_rdma_init)) {
         // Just for UT
@@ -920,7 +492,6 @@ ssize_t RdmaEndpoint::HandleCompletion(ibv_wc& wc) {
             if (wc.byte_len < (uint32_t)FLAGS_rdma_zerocopy_min_size) {
                 zerocopy = false;
             }
-            CHECK_NE(_state.load(butil::memory_order_relaxed), FALLBACK_TCP);
             if (zerocopy) {
                 _rbuf[_rq_received].cutn(&_socket->_read_buf, wc.byte_len);
             } else {
@@ -1603,30 +1174,8 @@ void RdmaEndpoint::PollCq(Socket* m) {
     }
 }
 
-std::string RdmaEndpoint::GetStateStr() const {
-    switch (_state.load(butil::memory_order_relaxed)) {
-    case UNINIT: return "UNINIT";
-    case C_ALLOC_QPCQ: return "C_ALLOC_QPCQ";
-    case C_HELLO_SEND: return "C_HELLO_SEND";
-    case C_HELLO_WAIT: return "C_HELLO_WAIT";
-    case C_BRINGUP_QP: return "C_BRINGUP_QP";
-    case C_ACK_SEND: return "C_ACK_SEND";
-    case S_HELLO_WAIT: return "S_HELLO_WAIT";
-    case S_ALLOC_QPCQ: return "S_ALLOC_QPCQ";
-    case S_BRINGUP_QP: return "S_BRINGUP_QP";
-    case S_HELLO_SEND: return "S_HELLO_SEND";
-    case S_ACK_WAIT: return "S_ACK_WAIT";
-    case ESTABLISHED: return "ESTABLISHED";
-    case FALLBACK_TCP: return "FALLBACK_TCP";
-    case FAILED: return "FAILED";
-    default: return "UNKNOWN";
-    }
-}
-
 void RdmaEndpoint::DebugInfo(std::ostream& os, butil::StringPiece connector) const {
     os << "rdma_state=ON"
-       << connector << "handshake_state=" << GetStateStr()
-       << connector << "handshake_version=" << static_cast<int>(_handshake_version)
        << connector << "rdma_sq_imm_window_size=" << _sq_imm_window_size
        << connector << "rdma_remote_rq_window_size=" << _remote_rq_window_size.load(butil::memory_order_relaxed)
        << connector << "rdma_sq_window_size=" << _sq_window_size.load(butil::memory_order_relaxed)
diff --git a/src/brpc/rdma/rdma_endpoint.h b/src/brpc/rdma/rdma_endpoint.h
index 03bec81408..9237c6fe1d 100644
--- a/src/brpc/rdma/rdma_endpoint.h
+++ b/src/brpc/rdma/rdma_endpoint.h
@@ -36,6 +36,7 @@
 
 namespace brpc {
 class Socket;
+class RdmaTransport;
 namespace rdma {
 
 DECLARE_bool(rdma_use_polling);
@@ -50,15 +51,9 @@ struct ParsedHello;
 enum class RemoteHelloResult;
 class RdmaHello;
 class RdmaEndpoint;
-namespace v2_wire {
-    RemoteHelloResult ReadBodyAndNegotiate(RdmaEndpoint* ep, ParsedHello* remote);
-    int DrainBytes(RdmaEndpoint* ep, size_t n);
-}  // namespace v2_wire
 
 namespace v3_wire {
     void FillLocalRdmaHello(const RdmaEndpoint* ep, RdmaHello* msg);
-    int  ReadAndParseV3Hello(RdmaEndpoint* ep, RdmaHello* out);
-    int  WriteV3Hello(RdmaEndpoint* ep, const RdmaHello& msg);
 }  // namespace v3_wire
 
 class RdmaConnect : public AppConnect {
@@ -99,15 +94,40 @@ friend class RdmaHandshakeClientV2;
 friend class RdmaHandshakeServerV2;
 friend class RdmaHandshakeClientV3;
 friend class RdmaHandshakeServerV3;
-friend RemoteHelloResult v2_wire::ReadBodyAndNegotiate(RdmaEndpoint*, ParsedHello*);
-friend int v2_wire::DrainBytes(RdmaEndpoint*, size_t);
+friend class ::brpc::RdmaTransport;
 friend void v3_wire::FillLocalRdmaHello(const RdmaEndpoint*, RdmaHello*);
-friend int v3_wire::ReadAndParseV3Hello(RdmaEndpoint*, RdmaHello*);
-friend int v3_wire::WriteV3Hello(RdmaEndpoint*, const RdmaHello&);
 public:
     explicit RdmaEndpoint(Socket* s);
     ~RdmaEndpoint() override;
 
+#ifdef UNIT_TEST
+    // Compatibility view for existing handshake tests. Production builds do
+    // not store handshake state in the endpoint; the value is read from the
+    // owning transport.
+    enum State {
+        UNINIT = 0x0,
+        C_ALLOC_QPCQ = 0x1,
+        C_HELLO_SEND = 0x2,
+        C_HELLO_WAIT = 0x3,
+        C_BRINGUP_QP = 0x4,
+        C_ACK_SEND = 0x5,
+        S_HELLO_WAIT = 0x11,
+        S_ALLOC_QPCQ = 0x12,
+        S_BRINGUP_QP = 0x13,
+        S_HELLO_SEND = 0x14,
+        S_ACK_WAIT = 0x15,
+        ESTABLISHED = 0x100,
+        FALLBACK_TCP = 0x200,
+        FAILED = 0x300
+    };
+    struct StateView {
+        explicit StateView(Socket* socket) : _socket(socket) {}
+        operator State() const;
+        Socket* _socket;
+    };
+    StateView _state;
+#endif
+
     // Global initialization
     // Return 0 if success, -1 if failed and errno set
     static int GlobalInitialize();
@@ -128,13 +148,6 @@ friend int v3_wire::WriteV3Hello(RdmaEndpoint*, const RdmaHello&);
     void DebugInfo(std::ostream& os,
                    butil::StringPiece connector = "\n") const;
 
-    // Callback when there is new epollin event on TCP fd.
-    // Only used by client-side RDMA sockets.
-    static void OnNewDataFromTcp(Socket* m);
-
-    // Real handshake for RDMA-mode sockets.
-    static ParseResult ExecuteServerHandshake(butil::IOBuf* source, Socket* socket);
-
     // Initialize polling mode
     static int PollingModeInitialize(bthread_tag_t tag,
                                      std::function<void(void)> callback,
@@ -144,26 +157,6 @@ friend int v3_wire::WriteV3Hello(RdmaEndpoint*, const RdmaHello&);
     static void PollingModeRelease(bthread_tag_t tag);
 
 private:
-    enum State {
-        UNINIT = 0x0,
-        C_ALLOC_QPCQ = 0x1,
-        C_HELLO_SEND = 0x2,
-        C_HELLO_WAIT = 0x3,
-        C_BRINGUP_QP = 0x4,
-        C_ACK_SEND = 0x5,
-        S_HELLO_WAIT = 0x11,
-        S_ALLOC_QPCQ = 0x12,
-        S_BRINGUP_QP = 0x13,
-        S_HELLO_SEND = 0x14,
-        S_ACK_WAIT = 0x15,
-        ESTABLISHED = 0x100,
-        FALLBACK_TCP = 0x200,
-        FAILED = 0x300
-    };
-
-    // Process handshake at the client
-    static void* ProcessHandshakeAtClient(void* arg);
-
     // Allocate resources. On failure the endpoint is left with no RDMA
     // resource attached, so that the handshake can safely fall back to TCP.
     // Return 0 if success, -1 if failed and errno set
@@ -214,27 +207,9 @@ friend int v3_wire::WriteV3Hello(RdmaEndpoint*, const RdmaHello&);
     //     -1:  failed, errno set
     int DoPostRecv(void* block, size_t block_size);
 
-    // Read at most len bytes from fd in _socket to data
-    // wait for _read_butex if encounter EAGAIN
-    // return -1 if encounter other errno (including EOF)
-    int ReadFromFd(void* data, size_t len);
-    int ReadFromFd(butil::IOPortal* data, size_t len);
-
-
-    // Write at most len bytes from data to fd in _socket
-    // wait for _epollout_butex if encounter EAGAIN
-    // return -1 if encounter other errno
-    int WriteToFd(void* data, size_t len);
-
-    // Write data to fd in _socket.
-    // wait for _epollout_butex if encounter EAGAIN.
-    // return -1 if encounter other errno.
-    int WriteToFd(butil::IOBuf* data);
-
-    // Copy negotiated remote parameters into the endpoint and compute
-    // the SQ/RQ window capacities. Called by both
-    // ProcessHandshakeAtClient and ProcessHandshakeAtServer after the
-    // peer's hello has been validated.
+    // Copy negotiated remote parameters into the endpoint and compute the
+    // SQ/RQ window capacities. Called by RdmaTransport after the peer's hello
+    // has been validated.
     void ApplyRemoteHello(const ParsedHello& remote);
 
     // Bringup the QP from RESET state to RTS state.
@@ -255,9 +230,6 @@ friend int v3_wire::WriteV3Hello(RdmaEndpoint*, const RdmaHello&);
     // Poll CQ and get the work completion
     static void PollCq(Socket* m);
 
-    // Get the description of current handshake state
-    std::string GetStateStr() const;
-
     // Add cq socket id to poller
     void PollerAddCqSid();
 
@@ -267,19 +239,6 @@ friend int v3_wire::WriteV3Hello(RdmaEndpoint*, const RdmaHello&);
     // Not owner
     Socket* _socket;
 
-    // State of Handshake. FALLBACK_TCP publishes RdmaTransport::_rdma_state
-    // with release ordering and is consumed by OnNewDataFromTcp with acquire
-    // ordering. Other state accesses do not publish data and use relaxed
-    // ordering.
-    butil::atomic<State> _state;
-
-    // Wire-level handshake protocol version (set by dispatch in
-    // ProcessHandshakeAtClient/Server). Aligned with the protocol code:
-    //   0 = unnegotiated
-    //   2 = v2 "RDMA"
-    //   3 = v3 "RDM3"
-    int _handshake_version;
-
     // ECE payload to advertise in the next local hello:
     //   Client: the locally queried ECE capabilities (filled
     //           before C_HELLO_SEND);
@@ -336,9 +295,6 @@ friend int v3_wire::WriteV3Hello(RdmaEndpoint*, const RdmaHello&);
     // The number of new WRs posted in the local Recv Queue
     butil::atomic<uint16_t> _new_rq_wrs;
 
-    // butex for inform read events on TCP fd during handshake
-    butil::atomic<int> *_read_butex;
-
     DISALLOW_COPY_AND_ASSIGN(RdmaEndpoint);
 
     // Cq socket id operation type
diff --git a/src/brpc/rdma/rdma_handshake.cpp b/src/brpc/rdma/rdma_handshake.cpp
index 180c2b3f0b..8e7616e0aa 100644
--- a/src/brpc/rdma/rdma_handshake.cpp
+++ b/src/brpc/rdma/rdma_handshake.cpp
@@ -61,6 +61,8 @@ DECLARE_bool(rdma_trace_verbose);
 
 namespace v2_wire {
 
+int DrainBytes(handshake::SocketHandshakeIO* io, size_t n);
+
 void HelloMessage::Serialize(void* data) const {
     butil::RawPacker(data)
         .pack16(msg_len)
@@ -106,9 +108,10 @@ static void TranslateV2Hello(const HelloMessage& msg, ParsedHello* out) {
     out->qp_num = msg.qp_num;
 }
 
-RemoteHelloResult ReadBodyAndNegotiate(RdmaEndpoint* ep, ParsedHello* remote) {
+RemoteHelloResult ReadBodyAndNegotiate(handshake::SocketHandshakeIO* io,
+                                       ParsedHello* remote) {
     uint8_t data[HELLO_V2_MSG_LEN_MIN];
-    if (ep->ReadFromFd(data, HELLO_V2_MSG_LEN_MIN - HELLO_MAGIC_LEN) < 0) {
+    if (io->ReadExact(data, HELLO_V2_MSG_LEN_MIN - HELLO_MAGIC_LEN) < 0) {
         return RemoteHelloResult::ERROR;
     }
     HelloMessage remote_msg{};
@@ -124,7 +127,7 @@ RemoteHelloResult ReadBodyAndNegotiate(RdmaEndpoint* ep, ParsedHello* remote) {
         // carry enough information for negotiation; unknown trailing
         // bytes are treated as optional hints that v2 safely ignores.
         size_t ext_len = remote_msg.msg_len - HELLO_V2_MSG_LEN_MIN;
-        if (DrainBytes(ep, ext_len) < 0) {
+        if (DrainBytes(io, ext_len) < 0) {
             return RemoteHelloResult::ERROR;
         }
     }
@@ -135,11 +138,11 @@ RemoteHelloResult ReadBodyAndNegotiate(RdmaEndpoint* ep, ParsedHello* remote) {
     return RemoteHelloResult::NEGOTIATED;
 }
 
-int DrainBytes(RdmaEndpoint* ep, size_t n) {
+int DrainBytes(handshake::SocketHandshakeIO* io, size_t n) {
     uint8_t scratch[64];
     while (n > 0) {
         size_t chunk = std::min(n, sizeof(scratch));
-        if (ep->ReadFromFd(scratch, chunk) < 0) {
+        if (io->ReadExact(scratch, chunk) < 0) {
             return -1;
         }
         n -= chunk;
@@ -170,12 +173,12 @@ int RdmaHandshakeClientV2::SendLocalHello() {
     }
     fast_memcpy(data, HELLO_MAGIC, 4);
     local_msg.Serialize((char*)data + 4);
-    return ep->WriteToFd(data, HELLO_V2_MSG_LEN_MIN);
+    return _io->WriteAll(data, HELLO_V2_MSG_LEN_MIN);
 }
 
 RemoteHelloResult RdmaHandshakeClientV2::ReceiveAndParseRemoteHello(ParsedHello* remote) {
     uint8_t magic[HELLO_MAGIC_LEN];
-    if (_ep->ReadFromFd(magic, HELLO_MAGIC_LEN) < 0) {
+    if (_io->ReadExact(magic, HELLO_MAGIC_LEN) < 0) {
         return RemoteHelloResult::ERROR;
     }
     if (memcmp(magic, HELLO_MAGIC, HELLO_MAGIC_LEN) != 0) {
@@ -183,7 +186,7 @@ RemoteHelloResult RdmaHandshakeClientV2::ReceiveAndParseRemoteHello(ParsedHello*
         return RemoteHelloResult::ERROR;
     }
 
-    return v2_wire::ReadBodyAndNegotiate(_ep, remote);
+    return v2_wire::ReadBodyAndNegotiate(_io, remote);
 }
 
 // Parse one complete v2 client hello out of `_source` (non-blocking).
@@ -259,7 +262,7 @@ int RdmaHandshakeServerV2::SendLocalHello() {
     }
     fast_memcpy(data, HELLO_MAGIC, 4);
     local_msg.Serialize((char*)data + 4);
-    return _ep->WriteToFd(data, HELLO_V2_MSG_LEN_MIN);
+    return _io->WriteAll(data, HELLO_V2_MSG_LEN_MIN);
 }
 
 namespace v3_wire {
@@ -320,9 +323,9 @@ void FillLocalRdmaHello(const RdmaEndpoint* ep, RdmaHello* msg) {
     }
 }
 
-int ReadAndParseV3Hello(RdmaEndpoint* ep, RdmaHello* out) {
+int ReadAndParseV3Hello(handshake::SocketHandshakeIO* io, RdmaHello* out) {
     uint8_t size_buf[HELLO_V3_PB_SIZE_LEN];
-    if (ep->ReadFromFd(size_buf, HELLO_V3_PB_SIZE_LEN) < 0) {
+    if (io->ReadExact(size_buf, HELLO_V3_PB_SIZE_LEN) < 0) {
         return -1;
     }
     uint32_t pb_size = butil::NetToHost32(
@@ -332,7 +335,7 @@ int ReadAndParseV3Hello(RdmaEndpoint* ep, RdmaHello* out) {
         return -1;
     }
     butil::IOPortal body;
-    if (ep->ReadFromFd(&body, pb_size) < 0) {
+    if (io->ReadExact(&body, pb_size) < 0) {
         return -1;
     }
 
@@ -345,7 +348,7 @@ int ReadAndParseV3Hello(RdmaEndpoint* ep, RdmaHello* out) {
     return 0;
 }
 
-int WriteV3Hello(RdmaEndpoint* ep, const RdmaHello& msg) {
+int WriteV3Hello(handshake::SocketHandshakeIO* io, const RdmaHello& msg) {
     uint32_t pb_size = static_cast<uint32_t>(msg.ByteSizeLong());
     if (pb_size > HELLO_V3_MAX_PB_SIZE) {
         errno = EPROTO;
@@ -363,7 +366,7 @@ int WriteV3Hello(RdmaEndpoint* ep, const RdmaHello& msg) {
         errno = EPROTO;
         return -1;
     }
-    return ep->WriteToFd(&packet);
+    return io->WriteAll(&packet);
 }
 
 void TranslateHello(const RdmaHello& msg, ParsedHello* out) {
@@ -402,12 +405,12 @@ int RdmaHandshakeClientV3::SendLocalHello() {
 
     RdmaHello local_msg{};
     v3_wire::FillLocalRdmaHello(_ep, &local_msg);
-    return v3_wire::WriteV3Hello(_ep, local_msg);
+    return v3_wire::WriteV3Hello(_io, local_msg);
 }
 
 RemoteHelloResult RdmaHandshakeClientV3::ReceiveAndParseRemoteHello(ParsedHello* remote) {
     uint8_t magic[HELLO_MAGIC_LEN];
-    if (_ep->ReadFromFd(magic, HELLO_MAGIC_LEN) < 0) {
+    if (_io->ReadExact(magic, HELLO_MAGIC_LEN) < 0) {
         return RemoteHelloResult::ERROR;
     }
     if (memcmp(magic, HELLO_MAGIC_V3, HELLO_MAGIC_LEN) != 0) {
@@ -416,7 +419,7 @@ RemoteHelloResult RdmaHandshakeClientV3::ReceiveAndParseRemoteHello(ParsedHello*
     }
 
     RdmaHello remote_msg{};
-    if (v3_wire::ReadAndParseV3Hello(_ep, &remote_msg) < 0) {
+    if (v3_wire::ReadAndParseV3Hello(_io, &remote_msg) < 0) {
         return RemoteHelloResult::ERROR;
     }
     if (!v3_wire::ValidRdmaHello(remote_msg)) {
@@ -482,28 +485,30 @@ int RdmaHandshakeServerV3::SendLocalHello() {
     } else {
         v3_wire::FillLocalRdmaHello(_ep, &local_msg);
     }
-    return v3_wire::WriteV3Hello(_ep, local_msg);
+    return v3_wire::WriteV3Hello(_io, local_msg);
 }
 
-std::unique_ptr<RdmaHandshake> CreateClientHandshake(RdmaEndpoint* ep) {
+std::unique_ptr<RdmaHandshake> CreateClientHandshake(
+    RdmaEndpoint* ep, handshake::SocketHandshakeIO* io) {
     switch (FLAGS_rdma_client_handshake_version) {
     case 3:
-        return std::unique_ptr<RdmaHandshake>(new RdmaHandshakeClientV3(ep));
+        return std::unique_ptr<RdmaHandshake>(new RdmaHandshakeClientV3(ep, io));
     case 2:
     default:
-        return std::unique_ptr<RdmaHandshake>(new RdmaHandshakeClientV2(ep));
+        return std::unique_ptr<RdmaHandshake>(new RdmaHandshakeClientV2(ep, io));
     }
 }
 
 std::unique_ptr<RdmaHandshake> CreateServerHandshakeByMagic(
-    RdmaEndpoint* ep, butil::IOBuf* source, const uint8_t magic[HELLO_MAGIC_LEN]) {
+    RdmaEndpoint* ep, handshake::SocketHandshakeIO* io, butil::IOBuf* source,
+    const uint8_t magic[HELLO_MAGIC_LEN]) {
     if (memcmp(magic, HELLO_MAGIC, HELLO_MAGIC_LEN) == 0) {
         return std::unique_ptr<RdmaHandshake>(
-                new RdmaHandshakeServerV2(ep, source));
+                new RdmaHandshakeServerV2(ep, io, source));
     }
     if (memcmp(magic, HELLO_MAGIC_V3, HELLO_MAGIC_LEN) == 0) {
         return std::unique_ptr<RdmaHandshake>(
-                new RdmaHandshakeServerV3(ep, source));
+                new RdmaHandshakeServerV3(ep, io, source));
     }
     return NULL;
 }
diff --git a/src/brpc/rdma/rdma_handshake.h b/src/brpc/rdma/rdma_handshake.h
index 6238d424f0..3befe815ab 100644
--- a/src/brpc/rdma/rdma_handshake.h
+++ b/src/brpc/rdma/rdma_handshake.h
@@ -25,6 +25,7 @@
 #include "butil/macros.h"
 #include "butil/containers/optional.h"
 #include "brpc/rdma/rdma_handshake_constants.h"
+#include "brpc/transport_handshake.h"
 
 namespace butil {
 class IOBuf;
@@ -37,9 +38,8 @@ class RdmaEndpoint;
 
 // Wire-format-agnostic representation of a peer's hello message.
 // Each protocol version (v2 binary, v3 protobuf) translates its own
-// wire format into this struct so the state-machine driver in
-// RdmaEndpoint::ProcessHandshakeAt{Client,Server} stays free of any
-// wire-format details.
+// wire format into this struct so the state-machine driver in RdmaTransport
+// stays free of any wire-format details.
 struct ParsedHello {
     uint32_t block_size;
     uint16_t sq_size;
@@ -90,7 +90,8 @@ struct HelloMessage {
 // Base class of an RDMA handshake, shared by both roles.
 class RdmaHandshake {
 public:
-    RdmaHandshake(RdmaEndpoint* ep, int version) : _ep(ep), _version(version) {}
+    RdmaHandshake(RdmaEndpoint* ep, handshake::SocketHandshakeIO* io, int version)
+        : _ep(ep), _io(io), _version(version) {}
     virtual ~RdmaHandshake() = default;
 
     DISALLOW_COPY_AND_ASSIGN(RdmaHandshake);
@@ -114,6 +115,7 @@ class RdmaHandshake {
 
 protected:
     RdmaEndpoint* _ep;
+    handshake::SocketHandshakeIO* _io;
     int _version;
 };
 
@@ -121,8 +123,9 @@ class RdmaHandshake {
 // `_source` (an IOBuf filled by InputMessenger), never touching the fd.
 class ServerRdmaHandshake : public RdmaHandshake {
 public:
-    ServerRdmaHandshake(RdmaEndpoint* ep, butil::IOBuf* source, int version)
-        : RdmaHandshake(ep, version), _source(source) {}
+    ServerRdmaHandshake(RdmaEndpoint* ep, handshake::SocketHandshakeIO* io,
+                        butil::IOBuf* source, int version)
+        : RdmaHandshake(ep, io, version), _source(source) {}
 
 protected:
     butil::IOBuf* _source;
@@ -131,15 +134,17 @@ class ServerRdmaHandshake : public RdmaHandshake {
 // v2 handshake (legacy "RDMA" magic, 36B binary HelloMessage).
 class RdmaHandshakeClientV2 : public RdmaHandshake {
 public:
-    explicit RdmaHandshakeClientV2(RdmaEndpoint* ep) : RdmaHandshake(ep, 2) {}
+    RdmaHandshakeClientV2(RdmaEndpoint* ep, handshake::SocketHandshakeIO* io)
+        : RdmaHandshake(ep, io, 2) {}
     int SendLocalHello() override;
     RemoteHelloResult ReceiveAndParseRemoteHello(ParsedHello* remote) override;
 };
 
 class RdmaHandshakeServerV2 : public ServerRdmaHandshake {
 public:
-    RdmaHandshakeServerV2(RdmaEndpoint* ep, butil::IOBuf* source)
-        : ServerRdmaHandshake(ep, source, 2) {}
+    RdmaHandshakeServerV2(RdmaEndpoint* ep, handshake::SocketHandshakeIO* io,
+                          butil::IOBuf* source)
+        : ServerRdmaHandshake(ep, io, source, 2) {}
     int SendLocalHello() override;
     RemoteHelloResult ReceiveAndParseRemoteHello(ParsedHello* remote) override;
 };
@@ -148,15 +153,17 @@ class RdmaHandshakeServerV2 : public ServerRdmaHandshake {
 // [ "RDM3" 4B ][ pb_size 4B (big-endian) ][ RdmaHello protobuf bytes ]
 class RdmaHandshakeClientV3 : public RdmaHandshake {
 public:
-    explicit RdmaHandshakeClientV3(RdmaEndpoint* ep) : RdmaHandshake(ep, 3) {}
+    RdmaHandshakeClientV3(RdmaEndpoint* ep, handshake::SocketHandshakeIO* io)
+        : RdmaHandshake(ep, io, 3) {}
     int SendLocalHello() override;
     RemoteHelloResult ReceiveAndParseRemoteHello(ParsedHello* remote) override;
 };
 
 class RdmaHandshakeServerV3 : public ServerRdmaHandshake {
 public:
-    RdmaHandshakeServerV3(RdmaEndpoint* ep, butil::IOBuf* source)
-        : ServerRdmaHandshake(ep, source, 3) {}
+    RdmaHandshakeServerV3(RdmaEndpoint* ep, handshake::SocketHandshakeIO* io,
+                          butil::IOBuf* source)
+        : ServerRdmaHandshake(ep, io, source, 3) {}
     int SendLocalHello() override;
     RemoteHelloResult ReceiveAndParseRemoteHello(ParsedHello* remote) override;
 };
@@ -168,7 +175,8 @@ class RdmaHandshakeServerV3 : public ServerRdmaHandshake {
 //   2 (default) -> RdmaHandshakeClientV2
 //   3           -> RdmaHandshakeClientV3
 // Other values fall back to V2.
-std::unique_ptr<RdmaHandshake> CreateClientHandshake(RdmaEndpoint* ep);
+std::unique_ptr<RdmaHandshake> CreateClientHandshake(
+    RdmaEndpoint* ep, handshake::SocketHandshakeIO* io);
 
 // Pick the server-side handshake based on the 4B magic already read.
 // Returns NULL if `magic` is not a recognized RDMA magic
@@ -176,7 +184,8 @@ std::unique_ptr<RdmaHandshake> CreateClientHandshake(RdmaEndpoint* ep);
 //   "RDMA" -> RdmaHandshakeServerV2
 //   "RDM3" -> RdmaHandshakeServerV3
 std::unique_ptr<RdmaHandshake> CreateServerHandshakeByMagic(
-    RdmaEndpoint* ep, butil::IOBuf* source, const uint8_t magic[HELLO_MAGIC_LEN]);
+    RdmaEndpoint* ep, handshake::SocketHandshakeIO* io, butil::IOBuf* source,
+    const uint8_t magic[HELLO_MAGIC_LEN]);
 
 }  // namespace rdma
 }  // namespace brpc
diff --git a/src/brpc/rdma/rdma_handshake_server.cpp b/src/brpc/rdma/rdma_handshake_server.cpp
index 4072a11c90..d52532dec2 100644
--- a/src/brpc/rdma/rdma_handshake_server.cpp
+++ b/src/brpc/rdma/rdma_handshake_server.cpp
@@ -22,27 +22,18 @@
 #include <string.h>
 #include "butil/iobuf.h"
 #include "butil/logging.h"
-#include "butil/object_pool.h"
 #include "butil/raw_pack.h"
 #include "butil/sys_byteorder.h"
 #include "brpc/socket.h"
 #include "brpc/rdma/rdma_handshake.pb.h"
 #include "brpc/rdma/rdma_handshake_constants.h"
 #if BRPC_WITH_RDMA
-#include "brpc/rdma/rdma_endpoint.h"
+#include "brpc/rdma_transport.h"
 #endif
 
 namespace brpc {
 namespace rdma {
 
-ServerHandshakeContext* ServerHandshakeContext::Create() {
-    return butil::get_object<ServerHandshakeContext>();
-}
-
-void ServerHandshakeContext::Destroy() {
-    butil::return_object(this);
-}
-
 // Fallback-only server handshake. Used for any connection that is NOT in RDMA
 // mode: builds without RDMA (no RdmaEndpoint exists at all), and RDMA-enabled
 // builds where this particular connection is plain TCP. Every RDMA client that
@@ -204,7 +195,7 @@ ParseResult ExecuteServerHandshake(butil::IOBuf* source, Socket* socket) {
     // this connection is plain TCP, or RDMA not compiled at all) falls back.
 #if BRPC_WITH_RDMA
     if (socket->socket_mode() == SOCKET_MODE_RDMA) {
-        return RdmaEndpoint::ExecuteServerHandshake(source, socket);
+        return RdmaTransport::ExecuteServerHandshake(source, socket);
     }
 #endif
     return FallbackServerHandshake(source, socket);
diff --git a/src/brpc/rdma/rdma_handshake_server.h b/src/brpc/rdma/rdma_handshake_server.h
index 705aa893ef..a91b625a1a 100644
--- a/src/brpc/rdma/rdma_handshake_server.h
+++ b/src/brpc/rdma/rdma_handshake_server.h
@@ -18,8 +18,8 @@
 #ifndef BRPC_RDMA_RDMA_HANDSHAKE_SERVER_H
 #define BRPC_RDMA_RDMA_HANDSHAKE_SERVER_H
 
-#include "brpc/destroyable.h"
 #include "brpc/parse_result.h"
+#include "brpc/transport_handshake.h"
 
 namespace butil {
 class IOBuf;
@@ -29,11 +29,7 @@ namespace brpc {
 class Socket;
 namespace rdma {
 
-// State kept across multiple parse calls of the server handshake.
-struct ServerHandshakeContext : public Destroyable {
-    static ServerHandshakeContext* Create();
-    void Destroy() override;
-};
+using ServerHandshakeContext = handshake::ServerHandshakeContext;
 
 // The single server-side RDMA handshake entry for policy::ParseRdmaHandshake.
 // Returns a ParseResult ready to be handed back from the protocol parser:
diff --git a/src/brpc/rdma_transport.cpp b/src/brpc/rdma_transport.cpp
index b172e47f34..e82ac325a5 100644
--- a/src/brpc/rdma_transport.cpp
+++ b/src/brpc/rdma_transport.cpp
@@ -17,11 +17,17 @@
 
 #if BRPC_WITH_RDMA
 
+#include <unistd.h>
+
 #include "brpc/rdma_transport.h"
+#include "butil/sys_byteorder.h"
 #include "brpc/event_dispatcher.h"
 #include "brpc/tcp_transport.h"
 #include "brpc/input_messenger.h"
 #include "brpc/rdma/rdma_endpoint.h"
+#include "brpc/rdma/rdma_handshake.h"
+#include "brpc/rdma/rdma_handshake_constants.h"
+#include "brpc/rdma/rdma_handshake_server.h"
 #include "brpc/rdma/rdma_helper.h"
 
 namespace brpc {
@@ -30,8 +36,292 @@ DECLARE_bool(usercode_in_pthread);
 
 extern SocketVarsCollector *g_vars;
 
+namespace rdma {
+
+DECLARE_bool(rdma_trace_verbose);
+
+void RdmaConnect::StartConnect(const Socket* socket,
+                               void (*done)(int err, void* data),
+                               void* data) {
+    RdmaTransport* transport =
+        static_cast<RdmaTransport*>(socket->_transport.get());
+    CHECK(transport->_rdma_ep != NULL);
+    SocketUniquePtr ptr;
+    if (Socket::Address(socket->id(), &ptr) != 0) {
+        return;
+    }
+    if (!IsRdmaAvailable()) {
+        transport->_handshake.PublishFallback([transport]() {
+            transport->_rdma_state = RdmaTransport::RDMA_OFF;
+        });
+        done(0, data);
+        return;
+    }
+    _done = done;
+    _data = data;
+    bthread_t tid;
+    bthread_attr_t attr = BTHREAD_ATTR_NORMAL;
+    bthread_attr_set_name(&attr, "RdmaProcessHandshakeAtClient");
+    if (bthread_start_background(&tid, &attr,
+                                 RdmaTransport::ProcessHandshakeAtClient,
+                                 transport) < 0) {
+        LOG(FATAL) << "Fail to start handshake bthread";
+        Run();
+    } else {
+        ptr.release();
+    }
+}
+
+void RdmaConnect::StopConnect(Socket*) {}
+
+void RdmaConnect::Run() {
+    _done(errno, _data);
+}
+
+}  // namespace rdma
+
+void RdmaTransport::OnNewDataFromTcp(Socket* socket) {
+    RdmaTransport* transport =
+        static_cast<RdmaTransport*>(socket->_transport.get());
+    CHECK(transport->_rdma_ep != NULL);
+
+    int progress = Socket::PROGRESS_INIT;
+    while (true) {
+        // Acquire pairs with PublishFallback's release store. In particular,
+        // RDMA_OFF is visible before InputMessenger resumes TCP parsing.
+        const int state = transport->_handshake.phase();
+        if (state == UNINIT) {
+            // The client handshake bthread has not started yet.
+        } else if (state < ESTABLISHED) {
+            transport->_handshake.NotifyReadable();
+        } else if (state == FALLBACK_TCP) {
+            InputMessenger::OnNewMessages(socket);
+            return;
+        } else if (state == ESTABLISHED) {
+            uint8_t byte;
+            const ssize_t nr = read(socket->fd(), &byte, 1);
+            if (nr == 0) {
+                socket->SetEOF();
+                return;
+            }
+            if (nr > 0) {
+                socket->SetFailed(EPROTO, "Read unexpected data from %s",
+                                  socket->description().c_str());
+                return;
+            }
+            if (errno != EAGAIN) {
+                const int saved_errno = errno;
+                socket->SetFailed(saved_errno, "Fail to read from %s: %s",
+                                  socket->description().c_str(),
+                                  berror(saved_errno));
+                return;
+            }
+        }
+        if (!socket->MoreReadEvents(&progress)) {
+            break;
+        }
+    }
+}
+
+void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
+    RdmaTransport* transport = static_cast<RdmaTransport*>(arg);
+    rdma::RdmaEndpoint* ep = transport->_rdma_ep;
+    SocketUniquePtr socket(transport->_socket);
+    rdma::RdmaConnect::RunGuard guard(
+        static_cast<rdma::RdmaConnect*>(socket->_app_connect.get()));
+
+    LOG_IF(INFO, rdma::FLAGS_rdma_trace_verbose)
+        << "Start handshake on " << socket->description();
+
+    std::unique_ptr<rdma::RdmaHandshake> handshake =
+        rdma::CreateClientHandshake(ep, &transport->_handshake);
+    CHECK(handshake != NULL);
+    transport->_handshake_version = handshake->ProtocolVersion();
+
+    transport->_handshake.SetPhase(C_ALLOC_QPCQ);
+    if (ep->AllocateResources() < 0) {
+        PLOG(WARNING) << "Fail to allocate rdma resources, fallback to tcp:"
+                      << socket->description();
+        // Resource preparation is transactional (see #3424): partial RDMA
+        // resources are cleaned by AllocateResources and TCP remains usable.
+        errno = 0;
+        transport->_handshake.PublishFallback([transport]() {
+            transport->_rdma_state = RDMA_OFF;
+        });
+        return NULL;
+    }
+
+    transport->_handshake.SetPhase(C_HELLO_SEND);
+    if (handshake->SendLocalHello() < 0) {
+        const int saved_errno = errno;
+        socket->SetFailed(saved_errno,
+                          "Fail to complete rdma handshake from %s: %s",
+                          socket->description().c_str(), berror(saved_errno));
+        transport->_handshake.MarkFailed();
+        return NULL;
+    }
+
+    transport->_handshake.SetPhase(C_HELLO_WAIT);
+    rdma::ParsedHello remote{};
+    const rdma::RemoteHelloResult result =
+        handshake->ReceiveAndParseRemoteHello(&remote);
+    if (result == rdma::RemoteHelloResult::ERROR) {
+        const int saved_errno = errno;
+        socket->SetFailed(saved_errno,
+                          "Fail to complete rdma handshake from %s: %s",
+                          socket->description().c_str(), berror(saved_errno));
+        transport->_handshake.MarkFailed();
+        return NULL;
+    }
+
+    if (result != rdma::RemoteHelloResult::NEGOTIATED) {
+        transport->_rdma_state = RDMA_OFF;
+    } else {
+        ep->ApplyRemoteHello(remote);
+        transport->_handshake.SetPhase(C_BRINGUP_QP);
+        if (ep->BringUpQp(remote, false) < 0) {
+            LOG(WARNING) << "Fail to bringup QP, fallback to tcp:"
+                         << socket->description();
+            transport->_rdma_state = RDMA_OFF;
+        } else {
+            transport->_rdma_state = RDMA_ON;
+        }
+    }
+
+    transport->_handshake.SetPhase(C_ACK_SEND);
+    const bool rdma_on = transport->_rdma_state == RDMA_ON;
+    const uint32_t flags_be = butil::HostToNet32(
+        rdma_on ? rdma::HELLO_ACK_RDMA_OK : 0);
+    if (transport->_handshake.WriteAll(&flags_be, rdma::HELLO_ACK_LEN) < 0) {
+        const int saved_errno = errno;
+        socket->SetFailed(saved_errno,
+                          "Fail to complete rdma handshake from %s: %s",
+                          socket->description().c_str(), berror(saved_errno));
+        transport->_handshake.MarkFailed();
+        return NULL;
+    }
+
+    if (rdma_on) {
+        transport->_handshake.MarkEstablished();
+        LOG_IF(INFO, rdma::FLAGS_rdma_trace_verbose)
+            << "Client handshake ends (use rdma v"
+            << transport->_handshake_version << ") on "
+            << socket->description();
+    } else {
+        transport->_handshake.PublishFallback([transport]() {
+            transport->_rdma_state = RDMA_OFF;
+        });
+        LOG_IF(INFO, rdma::FLAGS_rdma_trace_verbose)
+            << "Client handshake ends (use tcp) on " << socket->description();
+    }
+    errno = 0;
+    return NULL;
+}
+
+ParseResult RdmaTransport::ExecuteServerHandshake(butil::IOBuf* source,
+                                                   Socket* socket) {
+    RdmaTransport* transport =
+        static_cast<RdmaTransport*>(socket->_transport.get());
+    rdma::RdmaEndpoint* ep = transport->_rdma_ep;
+    CHECK(ep != NULL);
+
+    if (socket->parsing_context() == NULL) {
+        if (source->size() < rdma::HELLO_MAGIC_LEN) {
+            return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
+        }
+        uint8_t magic[rdma::HELLO_MAGIC_LEN];
+        CHECK_EQ(source->copy_to(magic, sizeof(magic)), sizeof(magic));
+        std::unique_ptr<rdma::RdmaHandshake> handshake =
+            rdma::CreateServerHandshakeByMagic(
+                ep, &transport->_handshake, source, magic);
+        if (handshake == NULL) {
+            return MakeParseError(PARSE_ERROR_TRY_OTHERS);
+        }
+        transport->_handshake_version = handshake->ProtocolVersion();
+        transport->_handshake.SetPhase(S_HELLO_WAIT);
+
+        rdma::ParsedHello remote{};
+        const rdma::RemoteHelloResult result =
+            handshake->ReceiveAndParseRemoteHello(&remote);
+        if (result == rdma::RemoteHelloResult::NEED_MORE) {
+            return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
+        }
+        if (result == rdma::RemoteHelloResult::ERROR) {
+            transport->_handshake.MarkFailed();
+            return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
+        }
+
+        bool negotiated = result == rdma::RemoteHelloResult::NEGOTIATED;
+        if (negotiated) {
+            ep->ApplyRemoteHello(remote);
+            transport->_handshake.SetPhase(S_ALLOC_QPCQ);
+            if (ep->AllocateResources() < 0) {
+                PLOG(WARNING) << "Fail to allocate rdma resources, fallback to tcp:"
+                              << socket->description();
+                negotiated = false;
+            } else {
+                transport->_handshake.SetPhase(S_BRINGUP_QP);
+                if (ep->BringUpQp(remote, true) < 0) {
+                    negotiated = false;
+                }
+            }
+        }
+        if (!negotiated) {
+            transport->_rdma_state = RDMA_OFF;
+        }
+
+        transport->_handshake.SetPhase(S_HELLO_SEND);
+        if (handshake->SendLocalHello() < 0) {
+            transport->_handshake.MarkFailed();
+            return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
+        }
+        socket->reset_parsing_context(rdma::ServerHandshakeContext::Create());
+        transport->_handshake.SetPhase(S_ACK_WAIT);
+        return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
+    }
+
+    if (source->size() < rdma::HELLO_ACK_LEN) {
+        return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
+    }
+    uint32_t flags_be = 0;
+    CHECK_EQ(source->cutn(&flags_be, rdma::HELLO_ACK_LEN),
+             rdma::HELLO_ACK_LEN);
+    const bool client_ack_ok =
+        (butil::NetToHost32(flags_be) & rdma::HELLO_ACK_RDMA_OK) != 0;
+    if (!client_ack_ok) {
+        // Keep any coalesced RPC bytes in source. After the release-published
+        // fallback, InputMessenger will continue parsing them as TCP data.
+        transport->_handshake.PublishFallback([transport]() {
+            transport->_rdma_state = RDMA_OFF;
+        });
+        socket->reset_parsing_context(NULL);
+        return MakeParseError(PARSE_ERROR_TRY_OTHERS);
+    }
+
+    if (!source->empty()) {
+        // A successful RDMA upgrade must not carry application bytes on the
+        // TCP control connection after the ACK.
+        transport->_handshake.MarkFailed();
+        socket->reset_parsing_context(NULL);
+        return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
+    }
+
+    if (transport->_rdma_state == RDMA_OFF) {
+        transport->_handshake.MarkFailed();
+        socket->reset_parsing_context(NULL);
+        return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
+    }
+
+    transport->_rdma_state = RDMA_ON;
+    transport->_handshake.MarkEstablished();
+    socket->reset_parsing_context(NULL);
+    return MakeParseError(PARSE_ERROR_TRY_OTHERS);
+}
+
 void RdmaTransport::Init(Socket *socket, const SocketOptions &options) {
     CHECK(_rdma_ep == NULL);
+    _handshake.Reset(socket);
+    _handshake_version = 0;
     if (options.socket_mode == SOCKET_MODE_RDMA) {
         _rdma_ep = new(std::nothrow)rdma::RdmaEndpoint(socket);
         if (!_rdma_ep) {
@@ -52,10 +342,10 @@ void RdmaTransport::Init(Socket *socket, const SocketOptions &options) {
         // Server-side RDMA sockets drive the handshake through the standard
         // InputMessenger path (ParseRdmaHandshake), so they use OnNewMessages
         // just like TCP sockets. Only client-side sockets, whose handshake
-        // (ProcessHandshakeAtClient) is an active blocking bthread relying on
-        // _read_butex woken by OnNewDataFromTcp, still need OnNewDataFromTcp.
+        // ProcessHandshakeAtClient is an active blocking bthread relying on
+        // SocketHandshakeIO being woken by OnNewDataFromTcp.
         if (options.user == static_cast<SocketUser*>(get_client_side_messenger())) {
-            _on_edge_trigger = rdma::RdmaEndpoint::OnNewDataFromTcp;
+            _on_edge_trigger = RdmaTransport::OnNewDataFromTcp;
         } else {
             _on_edge_trigger = InputMessenger::OnNewMessages;
         }
@@ -77,6 +367,8 @@ int RdmaTransport::Reset(int32_t expected_nref) {
         _rdma_ep->Reset();
         _rdma_state = RDMA_UNKNOWN;
     }
+    _handshake.Reset(_socket);
+    _handshake_version = 0;
     return 0;
 }
 
@@ -193,6 +485,25 @@ void RdmaTransport::Debug(std::ostream &os) {
     if (_rdma_state == RDMA_ON && _rdma_ep) {
         _rdma_ep->DebugInfo(os);
     }
+    const char* state = "UNKNOWN";
+    switch (_handshake.phase(butil::memory_order_relaxed)) {
+    case UNINIT: state = "UNINIT"; break;
+    case C_ALLOC_QPCQ: state = "C_ALLOC_QPCQ"; break;
+    case C_HELLO_SEND: state = "C_HELLO_SEND"; break;
+    case C_HELLO_WAIT: state = "C_HELLO_WAIT"; break;
+    case C_BRINGUP_QP: state = "C_BRINGUP_QP"; break;
+    case C_ACK_SEND: state = "C_ACK_SEND"; break;
+    case S_HELLO_WAIT: state = "S_HELLO_WAIT"; break;
+    case S_ALLOC_QPCQ: state = "S_ALLOC_QPCQ"; break;
+    case S_BRINGUP_QP: state = "S_BRINGUP_QP"; break;
+    case S_HELLO_SEND: state = "S_HELLO_SEND"; break;
+    case S_ACK_WAIT: state = "S_ACK_WAIT"; break;
+    case ESTABLISHED: state = "ESTABLISHED"; break;
+    case FALLBACK_TCP: state = "FALLBACK_TCP"; break;
+    case FAILED: state = "FAILED"; break;
+    }
+    os << "\nhandshake_state=" << state
+       << "\nhandshake_version=" << _handshake_version;
 }
 
 int RdmaTransport::ContextInitOrDie(bool serverOrNot, const void* _options) {
diff --git a/src/brpc/rdma_transport.h b/src/brpc/rdma_transport.h
index 0ac8a25324..db955f5b34 100644
--- a/src/brpc/rdma_transport.h
+++ b/src/brpc/rdma_transport.h
@@ -22,6 +22,7 @@
 #include "brpc/socket.h"
 #include "brpc/channel.h"
 #include "brpc/transport.h"
+#include "brpc/transport_handshake.h"
 
 namespace brpc {
 class RdmaTransport : public Transport {
@@ -31,6 +32,23 @@ friend class rdma::RdmaConnect;
 friend class rdma::RdmaHandshakeServerV2;
 friend class rdma::RdmaHandshakeServerV3;
 public:
+    enum HandshakeState {
+        UNINIT = 0x0,
+        C_ALLOC_QPCQ = 0x1,
+        C_HELLO_SEND = 0x2,
+        C_HELLO_WAIT = 0x3,
+        C_BRINGUP_QP = 0x4,
+        C_ACK_SEND = 0x5,
+        S_HELLO_WAIT = 0x11,
+        S_ALLOC_QPCQ = 0x12,
+        S_BRINGUP_QP = 0x13,
+        S_HELLO_SEND = 0x14,
+        S_ACK_WAIT = 0x15,
+        ESTABLISHED = handshake::ESTABLISHED,
+        FALLBACK_TCP = handshake::FALLBACK_TCP,
+        FAILED = handshake::FAILED
+    };
+
     void Init(Socket* socket, const SocketOptions& options) override;
     void Release() override;
     int Reset(int32_t expected_nref) override;
@@ -45,7 +63,17 @@ friend class rdma::RdmaHandshakeServerV3;
         CHECK(_rdma_ep != NULL);
         return _rdma_ep;
     }
+    int handshake_phase() const {
+        return _handshake.phase();
+    }
     static int ContextInitOrDie(bool serverOrNot, const void* _options);
+
+    // TCP control-plane callbacks. The endpoint is intentionally absent from
+    // these entry points and only participates through resource operations.
+    static void OnNewDataFromTcp(Socket* socket);
+    static void* ProcessHandshakeAtClient(void* arg);
+    static ParseResult ExecuteServerHandshake(butil::IOBuf* source,
+                                              Socket* socket);
 private:
     static bool OptionsAvailableForRdma(const ChannelOptions* opt);
     static bool OptionsAvailableOverRdma(const ServerOptions* opt);
@@ -61,7 +89,9 @@ friend class rdma::RdmaHandshakeServerV3;
     // Should use RDMA or not
     RdmaState _rdma_state;
     std::shared_ptr<TcpTransport>  _tcp_transport;
+    handshake::SocketHandshakeIO _handshake;
+    int _handshake_version = 0;
 };
 } // namespace brpc
 #endif // BRPC_WITH_RDMA
-#endif //BRPC_RDMA_TRANSPORT_H
\ No newline at end of file
+#endif //BRPC_RDMA_TRANSPORT_H
diff --git a/src/brpc/transport_handshake.cpp b/src/brpc/transport_handshake.cpp
new file mode 100644
index 0000000000..934dca6a6b
--- /dev/null
+++ b/src/brpc/transport_handshake.cpp
@@ -0,0 +1,156 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "brpc/transport_handshake.h"
+
+#include <cstdint>
+#include <errno.h>
+#include <unistd.h>
+
+#include "bthread/butex.h"
+#include "butil/time.h"
+#include "butil/logging.h"
+#include "butil/object_pool.h"
+#include "brpc/errno.pb.h"
+#include "brpc/socket.h"
+
+namespace brpc {
+namespace handshake {
+
+ServerHandshakeContext* ServerHandshakeContext::Create() {
+    return butil::get_object<ServerHandshakeContext>();
+}
+
+void ServerHandshakeContext::Destroy() {
+    butil::return_object(this);
+}
+
+static const int WAIT_TIMEOUT_MS = 50;
+
+SocketHandshakeIO::SocketHandshakeIO(Socket* socket)
+    : _socket(socket)
+    , _phase(UNINITIALIZED)
+    , _read_butex(bthread::butex_create_checked<butil::atomic<int> >()) {
+}
+
+SocketHandshakeIO::~SocketHandshakeIO() {
+    bthread::butex_destroy(_read_butex);
+}
+
+void SocketHandshakeIO::Reset(Socket* socket) {
+    _socket = socket;
+    _phase.store(UNINITIALIZED, butil::memory_order_relaxed);
+}
+
+void SocketHandshakeIO::NotifyReadable() {
+    _read_butex->fetch_add(1, butil::memory_order_release);
+    bthread::butex_wake(_read_butex);
+}
+
+template <typename ReadOnce>
+static int ReadExactLoop(butil::atomic<int>* read_butex,
+                         size_t len, ReadOnce read_once) {
+    size_t received = 0;
+    while (received < len) {
+        const int expected = read_butex->load(butil::memory_order_acquire);
+        const timespec duetime = butil::milliseconds_from_now(WAIT_TIMEOUT_MS);
+        const ssize_t nr = read_once(received, len - received);
+        if (nr < 0) {
+            if (errno != EAGAIN) {
+                return -1;
+            }
+            if (bthread::butex_wait(read_butex, expected, &duetime) < 0 &&
+                errno != EWOULDBLOCK && errno != ETIMEDOUT) {
+                return -1;
+            }
+        } else if (nr == 0) {
+            errno = EEOF;
+            return -1;
+        } else {
+            received += nr;
+        }
+    }
+    return 0;
+}
+
+int SocketHandshakeIO::ReadExact(void* data, size_t len) {
+    CHECK(data != NULL);
+    CHECK(_socket != NULL);
+    const int fd = _socket->fd();
+    return ReadExactLoop(_read_butex, len,
+        [data, fd](size_t offset, size_t remaining) {
+            return read(fd, static_cast<uint8_t*>(data) + offset, remaining);
+        });
+}
+
+int SocketHandshakeIO::ReadExact(butil::IOPortal* data, size_t len) {
+    CHECK(data != NULL);
+    CHECK(_socket != NULL);
+    const int fd = _socket->fd();
+    return ReadExactLoop(_read_butex, len,
+        [data, fd](size_t, size_t remaining) {
+            return data->append_from_file_descriptor(fd, remaining);
+        });
+}
+
+template <typename WriteOnce>
+static int WriteAllLoop(Socket* socket, size_t len, WriteOnce write_once) {
+    size_t written = 0;
+    while (written < len) {
+        const timespec duetime = butil::milliseconds_from_now(WAIT_TIMEOUT_MS);
+        const ssize_t nw = write_once(written, len - written);
+        if (nw > 0) {
+            written += nw;
+            continue;
+        }
+        if (nw == 0) {
+            errno = EPIPE;
+            return -1;
+        }
+        if (errno != EAGAIN) {
+            return -1;
+        }
+        if (socket->WaitEpollOut(socket->fd(), true, &duetime) < 0 &&
+            errno != ETIMEDOUT) {
+            return -1;
+        }
+    }
+    return 0;
+}
+
+int SocketHandshakeIO::WriteAll(const void* data, size_t len) {
+    CHECK(data != NULL);
+    CHECK(_socket != NULL);
+    const int fd = _socket->fd();
+    return WriteAllLoop(_socket, len,
+        [data, fd](size_t offset, size_t remaining) {
+            return write(fd, static_cast<const uint8_t*>(data) + offset, remaining);
+        });
+}
+
+int SocketHandshakeIO::WriteAll(butil::IOBuf* data) {
+    CHECK(data != NULL);
+    CHECK(_socket != NULL);
+    const int fd = _socket->fd();
+    return WriteAllLoop(_socket, data->size(),
+        [data, fd](size_t, size_t) {
+            return data->cut_into_file_descriptor(fd);
+        });
+}
+
+}  // namespace handshake
+}  // namespace brpc
diff --git a/src/brpc/transport_handshake.h b/src/brpc/transport_handshake.h
new file mode 100644
index 0000000000..03e4cb9f53
--- /dev/null
+++ b/src/brpc/transport_handshake.h
@@ -0,0 +1,108 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#ifndef BRPC_TRANSPORT_HANDSHAKE_H
+#define BRPC_TRANSPORT_HANDSHAKE_H
+
+#include <cstddef>
+
+#include "butil/atomicops.h"
+#include "butil/iobuf.h"
+#include "butil/macros.h"
+#include "brpc/destroyable.h"
+
+namespace brpc {
+
+class Socket;
+
+namespace handshake {
+
+// Marker context retained by InputMessenger between the hello and ACK parse
+// calls. It is wire-format agnostic and reusable by every upgrade protocol.
+struct ServerHandshakeContext : public Destroyable {
+    static ServerHandshakeContext* Create();
+    void Destroy() override;
+};
+
+// Protocol adapters may use transport-specific intermediate values, but the
+// terminal values are shared so that the TCP event callback can make the same
+// acquire-side decision for RDMA, URMA and UBSHM.
+enum Phase {
+    UNINITIALIZED = 0,
+    NEGOTIATING = 1,
+    ESTABLISHED = 0x100,
+    FALLBACK_TCP = 0x200,
+    FAILED = 0x300,
+};
+
+// Owns all TCP-fd I/O and synchronization used while upgrading a connection.
+// High-speed endpoints deliberately do not own this object: they only prepare
+// and activate protocol-specific data-plane resources.
+class SocketHandshakeIO {
+public:
+    explicit SocketHandshakeIO(Socket* socket = NULL);
+    ~SocketHandshakeIO();
+
+    void Reset(Socket* socket);
+
+    int phase(butil::memory_order order = butil::memory_order_acquire) const {
+        return _phase.load(order);
+    }
+
+    void SetPhase(int phase) {
+        _phase.store(phase, butil::memory_order_relaxed);
+    }
+
+    void MarkEstablished() {
+        _phase.store(ESTABLISHED, butil::memory_order_release);
+    }
+
+    void MarkFailed() {
+        _phase.store(FAILED, butil::memory_order_release);
+    }
+
+    // The callback MUST publish the transport's TCP-active state. The release
+    // store then makes that state and any pushed-back bytes visible to the
+    // event thread that observes FALLBACK_TCP with an acquire load. This is
+    // the common form of the ordering fixes from #3347 and #3406.
+    template <typename PublishTcpActive>
+    void PublishFallback(PublishTcpActive publish_tcp_active) {
+        publish_tcp_active();
+        _phase.store(FALLBACK_TCP, butil::memory_order_release);
+    }
+
+    void NotifyReadable();
+
+    // Read/write exactly len bytes. EAGAIN is handled by waiting for the
+    // socket event callback; EOF is reported as EEOF.
+    int ReadExact(void* data, size_t len);
+    int ReadExact(butil::IOPortal* data, size_t len);
+    int WriteAll(const void* data, size_t len);
+    int WriteAll(butil::IOBuf* data);
+
+private:
+    Socket* _socket;
+    butil::atomic<int> _phase;
+    butil::atomic<int>* _read_butex;
+
+    DISALLOW_COPY_AND_ASSIGN(SocketHandshakeIO);
+};
+
+}  // namespace handshake
+}  // namespace brpc
+
+#endif  // BRPC_TRANSPORT_HANDSHAKE_H
diff --git a/src/brpc/ubshm/ub_endpoint.cpp b/src/brpc/ubshm/ub_endpoint.cpp
index ea965a45b3..39ff83800e 100644
--- a/src/brpc/ubshm/ub_endpoint.cpp
+++ b/src/brpc/ubshm/ub_endpoint.cpp
@@ -124,16 +124,13 @@ std::string HelloMessage::toString() const {
 UBShmEndpoint::UBShmEndpoint(Socket* s)
     : _socket(s)
     , _socket_id(s ? s->id() : INVALID_SOCKET_ID)
-    , _state(UNINIT)
     , _ub_ring(nullptr)
     , _cq_sid(INVALID_SOCKET_ID)
 {
-    _read_butex = bthread::butex_create_checked<butil::atomic<int>>();
 }
 
 UBShmEndpoint::~UBShmEndpoint() {
     Reset();
-    bthread::butex_destroy(_read_butex);
 }
 
 void UBShmEndpoint::Reset() {
@@ -142,7 +139,6 @@ void UBShmEndpoint::Reset() {
     delete _ub_ring;
     _ub_ring = nullptr;
     _cq_sid = INVALID_SOCKET_ID;
-    _state = UNINIT;
 }
 
 void UBConnect::StartConnect(const Socket* socket,
@@ -155,8 +151,9 @@ void UBConnect::StartConnect(const Socket* socket,
         return;
     }
     if (!IsUBAvailable()) {
-        ub_transport->_ub_ep->_state = UBShmEndpoint::FALLBACK_TCP;
-        ub_transport->_ub_state = UBShmTransport::UB_OFF;
+        ub_transport->_handshake.PublishFallback([ub_transport]() {
+            ub_transport->_ub_state = UBShmTransport::UB_OFF;
+        });
         done(0, data);
         return;
     }
@@ -166,7 +163,7 @@ void UBConnect::StartConnect(const Socket* socket,
     bthread_attr_t attr = BTHREAD_ATTR_NORMAL;
     bthread_attr_set_name(&attr, "UBProcessHandshakeAtClient");
     if (bthread_start_background(&tid, &attr,
-                UBShmEndpoint::ProcessHandshakeAtClient, ub_transport->_ub_ep) < 0) {
+                UBShmTransport::ProcessHandshakeAtClient, ub_transport) < 0) {
         LOG(FATAL) << "Fail to start handshake bthread";
         Run();
     } else {
@@ -180,7 +177,13 @@ void UBConnect::Run() {
     _done(errno, _data);
 }
 
-static void TryReadOnTcpDuringRdmaEst(Socket* s) {
+}  // namespace ubring
+
+// Keep the wire constants and endpoint resource implementation in ubring,
+// while the connection-control state machine belongs to the Transport layer.
+using namespace ubring;
+
+static void TryReadOnTcpDuringUbEst(Socket* s) {
     int progress = Socket::PROGRESS_INIT;
     while (true) {
         uint8_t tmp;
@@ -208,29 +211,31 @@ static void TryReadOnTcpDuringRdmaEst(Socket* s) {
     }
 }
 
-void UBShmEndpoint::OnNewDataFromTcp(Socket* m) {
+void UBShmTransport::OnNewDataFromTcp(Socket* m) {
     auto* ub_transport = static_cast<UBShmTransport*>(m->_transport.get());
     UBShmEndpoint* ep = ub_transport->GetUBShmEp();
     CHECK(ep != NULL);
 
     int progress = Socket::PROGRESS_INIT;
     while (true) {
-        if (ep->_state == UNINIT) {
+        const int state = ub_transport->_handshake.phase();
+        if (state == UNINIT) {
             if (!m->CreatedByConnect()) {
                 if (!IsUBAvailable()) {
-                    ep->_state = FALLBACK_TCP;
-                    ub_transport->_ub_state = UBShmTransport::UB_OFF;
+                    ub_transport->_handshake.PublishFallback([ub_transport]() {
+                        ub_transport->_ub_state = UBShmTransport::UB_OFF;
+                    });
                     continue;
                 }
                 bthread_t tid;
-                ep->_state = S_HELLO_WAIT;
+                ub_transport->_handshake.SetPhase(S_HELLO_WAIT);
                 SocketUniquePtr s;
                 m->ReAddress(&s);
                 bthread_attr_t attr = BTHREAD_ATTR_NORMAL;
                 bthread_attr_set_name(&attr, "UBProcessHandshakeAtServer");
                 if (bthread_start_background(&tid, &attr,
-                            ProcessHandshakeAtServer, ep) < 0) {
-                    ep->_state = UNINIT;
+                            ProcessHandshakeAtServer, ub_transport) < 0) {
+                    ub_transport->_handshake.SetPhase(UNINIT);
                     LOG(FATAL) << "Fail to start handshake bthread";
                 } else {
                     s.release();
@@ -240,14 +245,13 @@ void UBShmEndpoint::OnNewDataFromTcp(Socket* m) {
                 // starts handshake. This will be handled by client handshake.
                 // Ignore the exception here.
             }
-        } else if (ep->_state < ESTABLISHED) {  // during handshake
-            ep->_read_butex->fetch_add(1, butil::memory_order_release);
-            bthread::butex_wake(ep->_read_butex);
-        } else if (ep->_state == FALLBACK_TCP){  // handshake finishes
+        } else if (state < ESTABLISHED) {  // during handshake
+            ub_transport->_handshake.NotifyReadable();
+        } else if (state == FALLBACK_TCP){  // handshake finishes
             InputMessenger::OnNewMessages(m);
             return;
-        } else if (ep->_state == ESTABLISHED) {
-            TryReadOnTcpDuringRdmaEst(ep->_socket);
+        } else if (state == ESTABLISHED) {
+            TryReadOnTcpDuringUbEst(ep->_socket);
             return;
         }
         if (!m->MoreReadEvents(&progress)) {
@@ -264,72 +268,20 @@ bool HelloNegotiationValid(HelloMessage& msg) {
     return false;
 }
 
-static const int WAIT_TIMEOUT_MS = 50;
-
-int UBShmEndpoint::ReadFromFd(void* data, size_t len) {
-    CHECK(data != NULL);
-    int nr = 0;
-    size_t received = 0;
-    do {
-        const timespec duetime = butil::milliseconds_from_now(WAIT_TIMEOUT_MS);
-        nr = read(_socket->fd(), (uint8_t*)data + received, len - received);
-        if (nr < 0) {
-            if (errno == EAGAIN) {
-                const int expected_val = _read_butex->load(butil::memory_order_acquire);
-                if (bthread::butex_wait(_read_butex, expected_val, &duetime) < 0) {
-                    if (errno != EWOULDBLOCK && errno != ETIMEDOUT) {
-                        return -1;
-                    }
-                }
-            } else {
-                return -1;
-            }
-        } else if (nr == 0) {
-            errno = EEOF;
-            return -1;
-        } else {
-            received += nr;
-        }
-    } while (received < len);
-    return 0;
-}
-
-int UBShmEndpoint::WriteToFd(void* data, size_t len) {
-    CHECK(data != NULL);
-    int nw = 0;
-    size_t written = 0;
-    do {
-        const timespec duetime = butil::milliseconds_from_now(WAIT_TIMEOUT_MS);
-        nw = write(_socket->fd(), (uint8_t*)data + written, len - written);
-        if (nw < 0) {
-            if (errno == EAGAIN) {
-                if (_socket->WaitEpollOut(_socket->fd(), true, &duetime) < 0) {
-                    if (errno != ETIMEDOUT) {
-                        return -1;
-                    }
-                }
-            } else {
-                return -1;
-            }
-        } else {
-            written += nw;
-        }
-    } while (written < len);
-    return 0;
-}
-
-inline void UBShmEndpoint::TryReadOnTcp() {
+void UBShmTransport::TryReadOnTcp() {
     if (_socket->_nevent.fetch_add(1, butil::memory_order_acq_rel) == 0) {
-        if (_state == FALLBACK_TCP) {
+        const int state = _handshake.phase();
+        if (state == FALLBACK_TCP) {
             InputMessenger::OnNewMessages(_socket);
-        } else if (_state == ESTABLISHED) {
-            TryReadOnTcpDuringRdmaEst(_socket);
+        } else if (state == ESTABLISHED) {
+            TryReadOnTcpDuringUbEst(_socket);
         }
     }
 }
 
-void* UBShmEndpoint::ProcessHandshakeAtClient(void* arg) {
-    UBShmEndpoint* ep = static_cast<UBShmEndpoint*>(arg);
+void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
+    UBShmTransport* ub_transport = static_cast<UBShmTransport*>(arg);
+    UBShmEndpoint* ep = ub_transport->_ub_ep;
     SocketUniquePtr s(ep->_socket);
     UBConnect::RunGuard rg((UBConnect*)s->_app_connect.get());
 
@@ -338,21 +290,22 @@ void* UBShmEndpoint::ProcessHandshakeAtClient(void* arg) {
 
     uint8_t data[g_ub_hello_msg_len];
 
-    ep->_state = C_ALLOC_SHM;
-    auto* ub_transport = static_cast<UBShmTransport*>(s->_transport.get());
+    ub_transport->_handshake.SetPhase(C_ALLOC_SHM);
     size_t local_shm_len = (size_t)(FLAGS_data_queue_size) * MB_TO_BYTE;
     SHM local_trx_shm = {NULL, local_shm_len, 0, {0}, (uint32_t)s->fd()};
     auto shm_name_str = butil::endpoint2str(s->local_side());
     const char* shm_name = shm_name_str.c_str();
     if (ep->AllocateClientResources(&local_trx_shm, shm_name) < 0) {
         LOG(WARNING) << "Fallback to tcp:" << s->description();
-        ub_transport->_ub_state = UBShmTransport::UB_OFF;
-        ep->_state = FALLBACK_TCP;
+        errno = 0;
+        ub_transport->_handshake.PublishFallback([ub_transport]() {
+            ub_transport->_ub_state = UBShmTransport::UB_OFF;
+        });
         return NULL;
     }
 
-    ep->_state = C_HELLO_SEND;
-    HelloMessage local_msg;
+    ub_transport->_handshake.SetPhase(C_HELLO_SEND);
+    HelloMessage local_msg{};
     local_msg.msg_len = g_ub_hello_msg_len;
     local_msg.hello_ver = g_ub_hello_version;
     local_msg.impl_ver = g_ub_impl_version;
@@ -360,49 +313,50 @@ void* UBShmEndpoint::ProcessHandshakeAtClient(void* arg) {
     memcpy(local_msg.shm_name, local_trx_shm.name, SHM_MAX_NAME_BUFF_LEN);
     memcpy(data, MAGIC_STR, MAGIC_STR_LEN);
     local_msg.Serialize((char*)data + MAGIC_STR_LEN);
-    if (ep->WriteToFd(data, g_ub_hello_msg_len) < 0) {
+    if (ub_transport->_handshake.WriteAll(data, g_ub_hello_msg_len) < 0) {
         const int saved_errno = errno;
         PLOG(WARNING) << "Fail to send hello message to server:" << s->description();
         s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(saved_errno));
-        ep->_state = FAILED;
+        ub_transport->_handshake.MarkFailed();
         return NULL;
     }
     LOG_IF(INFO, FLAGS_ub_trace_verbose) << "client handshake message : " << local_msg.toString();
 
-    ep->_state = C_HELLO_WAIT;
-    if (ep->ReadFromFd(data, MAGIC_STR_LEN) < 0) {
+    ub_transport->_handshake.SetPhase(C_HELLO_WAIT);
+    if (ub_transport->_handshake.ReadExact(data, MAGIC_STR_LEN) < 0) {
         const int saved_errno = errno;
         PLOG(WARNING) << "Fail to get hello message from server:" << s->description();
         s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(saved_errno));
-        ep->_state = FAILED;
+        ub_transport->_handshake.MarkFailed();
         return NULL;
     }
     if (memcmp(data, MAGIC_STR, MAGIC_STR_LEN) != 0) {
         LOG(WARNING) << "Read unexpected data during handshake:" << s->description();
         s->SetFailed(EPROTO, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(EPROTO));
-        ep->_state = FAILED;
+        ub_transport->_handshake.MarkFailed();
         return NULL;
     }
 
-    if (ep->ReadFromFd(data, HELLO_MSG_LEN_MIN - MAGIC_STR_LEN) < 0) {
+    if (ub_transport->_handshake.ReadExact(
+            data, HELLO_MSG_LEN_MIN - MAGIC_STR_LEN) < 0) {
         const int saved_errno = errno;
         PLOG(WARNING) << "Fail to get Hello Message from server:" << s->description();
         s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(saved_errno));
-        ep->_state = FAILED;
+        ub_transport->_handshake.MarkFailed();
         return NULL;
     }
-    HelloMessage remote_msg;
+    HelloMessage remote_msg{};
     remote_msg.Deserialize(data);
     if (remote_msg.msg_len < HELLO_MSG_LEN_MIN) {
         LOG(WARNING) << "Fail to parse Hello Message length from server:"
                      << s->description();
         s->SetFailed(EPROTO, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(EPROTO));
-        ep->_state = FAILED;
+        ub_transport->_handshake.MarkFailed();
         return NULL;
     }
 
@@ -416,7 +370,7 @@ void* UBShmEndpoint::ProcessHandshakeAtClient(void* arg) {
                      << s->description();
         ub_transport->_ub_state = UBShmTransport::UB_OFF;
     } else {
-        ep->_state = C_MAP_REMOTE_SHM;
+        ub_transport->_handshake.SetPhase(C_MAP_REMOTE_SHM);
         if (ep->_ub_ring->UbrMapRemoteShm(&local_trx_shm, shm_name) < 0) {
             LOG(WARNING) << "Fail to map the remote shm, fallback to tcp:" << s->description();
             ub_transport->_ub_state = UBShmTransport::UB_OFF;
@@ -425,29 +379,31 @@ void* UBShmEndpoint::ProcessHandshakeAtClient(void* arg) {
         }
     }
 
-    ep->_state = C_ACK_SEND;
+    ub_transport->_handshake.SetPhase(C_ACK_SEND);
     uint32_t flags = 0;
     if (ub_transport->_ub_state != UBShmTransport::UB_OFF) {
         flags |= ACK_MSG_UB_OK;
     }
     uint32_t* tmp = (uint32_t*)data;
     *tmp = butil::HostToNet32(flags);
-    if (ep->WriteToFd(data, ACK_MSG_LEN) < 0) {
+    if (ub_transport->_handshake.WriteAll(data, ACK_MSG_LEN) < 0) {
         const int saved_errno = errno;
         PLOG(WARNING) << "Fail to send Ack Message to server:" << s->description();
         s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(saved_errno));
-        ep->_state = FAILED;
+        ub_transport->_handshake.MarkFailed();
         return NULL;
     }
 
     if (ub_transport->_ub_state == UBShmTransport::UB_ON) {
-        ep->_state = ESTABLISHED;
+        ub_transport->_handshake.MarkEstablished();
         ep->_ub_ring->UbrUnlinkLocalShm();
         LOG_IF(INFO, FLAGS_ub_trace_verbose) 
             << "Client handshake ends (use ubring) on " << s->description();
     } else {
-        ep->_state = FALLBACK_TCP;
+        ub_transport->_handshake.PublishFallback([ub_transport]() {
+            ub_transport->_ub_state = UBShmTransport::UB_OFF;
+        });
         LOG_IF(INFO, FLAGS_ub_trace_verbose) 
             << "Client handshake ends (use tcp) on " << s->description();
     }
@@ -457,8 +413,9 @@ void* UBShmEndpoint::ProcessHandshakeAtClient(void* arg) {
     return NULL;
 }
 
-void* UBShmEndpoint::ProcessHandshakeAtServer(void* arg) {
-    UBShmEndpoint* ep = static_cast<UBShmEndpoint*>(arg);
+void* UBShmTransport::ProcessHandshakeAtServer(void* arg) {
+    UBShmTransport* ub_transport = static_cast<UBShmTransport*>(arg);
+    UBShmEndpoint* ep = ub_transport->_ub_ep;
     SocketUniquePtr s(ep->_socket);
 
     LOG_IF(INFO, FLAGS_ub_trace_verbose)
@@ -466,37 +423,38 @@ void* UBShmEndpoint::ProcessHandshakeAtServer(void* arg) {
 
     uint8_t data[g_ub_hello_msg_len];
 
-    ep->_state = S_HELLO_WAIT;
-    if (ep->ReadFromFd(data, MAGIC_STR_LEN) < 0) {
+    ub_transport->_handshake.SetPhase(S_HELLO_WAIT);
+    if (ub_transport->_handshake.ReadExact(data, MAGIC_STR_LEN) < 0) {
         const int saved_errno = errno;
         PLOG(WARNING) << "Fail to read Hello Message from client:" << s->description() << " " << s->_remote_side;
         s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(saved_errno));
-        ep->_state = FAILED;
+        ub_transport->_handshake.MarkFailed();
         return NULL;
     }
-    auto* ub_transport = static_cast<UBShmTransport*>(s->_transport.get());
     if (memcmp(data, MAGIC_STR, MAGIC_STR_LEN) != 0) {
         LOG_IF(INFO, FLAGS_ub_trace_verbose) << "It seems that the "
             << "client does not use RDMA, fallback to TCP:"
             << s->description();
         s->_read_buf.append(data, MAGIC_STR_LEN);
-        ep->_state = FALLBACK_TCP;
-        ub_transport->_ub_state = UBShmTransport::UB_OFF;
-        ep->TryReadOnTcp();
+        ub_transport->_handshake.PublishFallback([ub_transport]() {
+            ub_transport->_ub_state = UBShmTransport::UB_OFF;
+        });
+        ub_transport->TryReadOnTcp();
         return NULL;
     }
 
-    if (ep->ReadFromFd(data, g_ub_hello_msg_len - MAGIC_STR_LEN) < 0) {
+    if (ub_transport->_handshake.ReadExact(
+            data, g_ub_hello_msg_len - MAGIC_STR_LEN) < 0) {
         const int saved_errno = errno;
         PLOG(WARNING) << "Fail to read Hello Message from client:" << s->description();
         s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(saved_errno));
-        ep->_state = FAILED;
+        ub_transport->_handshake.MarkFailed();
         return NULL;
     }
 
-    HelloMessage remote_msg;
+    HelloMessage remote_msg{};
     remote_msg.Deserialize(data);
     LOG_IF(INFO, FLAGS_ub_trace_verbose) << "server receive handshake message : " << remote_msg.toString();
     if (remote_msg.msg_len < HELLO_MSG_LEN_MIN) {
@@ -504,7 +462,7 @@ void* UBShmEndpoint::ProcessHandshakeAtServer(void* arg) {
                      << s->description();
         s->SetFailed(EPROTO, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(EPROTO));
-        ep->_state = FAILED;
+        ub_transport->_handshake.MarkFailed();
         return NULL;
     }
     if (remote_msg.msg_len > HELLO_MSG_LEN_MIN) {
@@ -517,7 +475,7 @@ void* UBShmEndpoint::ProcessHandshakeAtServer(void* arg) {
                      << s->description();
         ub_transport->_ub_state = UBShmTransport::UB_OFF;
     } else {
-        ep->_state = S_ALLOC_SHM;
+        ub_transport->_handshake.SetPhase(S_ALLOC_SHM);
         ubring::SHM remote_trx_shm = {NULL, remote_msg.len, 0, {0}, (uint32_t)ep->_socket->fd()};
         strncpy(remote_trx_shm.name, remote_msg.shm_name, SHM_MAX_NAME_BUFF_LEN);
 
@@ -544,8 +502,8 @@ void* UBShmEndpoint::ProcessHandshakeAtServer(void* arg) {
         }
     }
 
-    ep->_state = S_HELLO_SEND;
-    HelloMessage local_msg;
+    ub_transport->_handshake.SetPhase(S_HELLO_SEND);
+    HelloMessage local_msg{};
     local_msg.msg_len = g_ub_hello_msg_len;
     if (ub_transport->_ub_state == UBShmTransport::UB_OFF) {
         local_msg.impl_ver = 0;
@@ -558,22 +516,22 @@ void* UBShmEndpoint::ProcessHandshakeAtServer(void* arg) {
     }
     memcpy(data, MAGIC_STR, MAGIC_STR_LEN);
     local_msg.Serialize((char*)data + MAGIC_STR_LEN);
-    if (ep->WriteToFd(data, g_ub_hello_msg_len) < 0) {
+    if (ub_transport->_handshake.WriteAll(data, g_ub_hello_msg_len) < 0) {
         const int saved_errno = errno;
         PLOG(WARNING) << "Fail to send Hello Message to client:" << s->description();
         s->SetFailed(saved_errno, "Fail to complete ub handshake from %s: %s",
                 s->description().c_str(), berror(saved_errno));
-        ep->_state = FAILED;
+        ub_transport->_handshake.MarkFailed();
         return NULL;
     }
 
-    ep->_state = S_ACK_WAIT;
-    if (ep->ReadFromFd(data, ACK_MSG_LEN) < 0) {
+    ub_transport->_handshake.SetPhase(S_ACK_WAIT);
+    if (ub_transport->_handshake.ReadExact(data, ACK_MSG_LEN) < 0) {
         const int saved_errno = errno;
         PLOG(WARNING) << "Fail to read ack message from client:" << s->description();
         s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(saved_errno));
-        ep->_state = FAILED;
+        ub_transport->_handshake.MarkFailed();
         return NULL;
     }
 
@@ -585,26 +543,29 @@ void* UBShmEndpoint::ProcessHandshakeAtServer(void* arg) {
                          << s->description();
             s->SetFailed(EPROTO, "Fail to complete ub handshake from %s: %s",
                     s->description().c_str(), berror(EPROTO));
-            ep->_state = FAILED;
+            ub_transport->_handshake.MarkFailed();
             return NULL;
         } else {
             ub_transport->_ub_state = UBShmTransport::UB_ON;
-            ep->_state = ESTABLISHED;
+            ub_transport->_handshake.MarkEstablished();
             ep->_ub_ring->UbrUnlinkLocalShm();
             LOG_IF(INFO, FLAGS_ub_trace_verbose) 
                 << "Server handshake ends (use ubring) on " << s->description();
         }
     } else {
-        ub_transport->_ub_state = UBShmTransport::UB_OFF;
-        ep->_state = FALLBACK_TCP;
+        ub_transport->_handshake.PublishFallback([ub_transport]() {
+            ub_transport->_ub_state = UBShmTransport::UB_OFF;
+        });
         LOG_IF(INFO, FLAGS_ub_trace_verbose) 
             << "Server handshake ends (use tcp) on " << s->description();
     }
-    ep->TryReadOnTcp();
+    ub_transport->TryReadOnTcp();
 
     return NULL;
 }
 
+namespace ubring {
+
 bool UBShmEndpoint::IsWritable() const {
     if (BAIDU_UNLIKELY(g_skip_ub_init)) {
         // Just for UT
@@ -679,11 +640,22 @@ int UBShmEndpoint::AllocateClientResources(ubring::SHM* local_trx_shm, const cha
     options.user = this;
     options.keytable_pool = _socket->_keytable_pool;
     if (Socket::Create(options, &_cq_sid) < 0) {
+        const int saved_errno = errno;
         PLOG(WARNING) << "Fail to create socket for cq";
+        delete _ub_ring;
+        _ub_ring = NULL;
+        _cq_sid = INVALID_SOCKET_ID;
+        errno = saved_errno;
         return -1;
     }
     int ret = _ub_ring->UbrAllocateLocalShm(local_trx_shm, shm_name);
     if (ret != 0) {
+        const int saved_errno = errno;
+        DeallocateResources();
+        delete _ub_ring;
+        _ub_ring = NULL;
+        _cq_sid = INVALID_SOCKET_ID;
+        errno = saved_errno;
         return ret;
     }
     PollerRegisterEvent(CqSidOp::ADD, EPOLLIN);
@@ -704,11 +676,22 @@ int UBShmEndpoint::AllocateServerResources(ubring::SHM* remote_trx_shm, ubring::
     options.user = this;
     options.keytable_pool = _socket->_keytable_pool;
     if (Socket::Create(options, &_cq_sid) < 0) {
+        const int saved_errno = errno;
         PLOG(WARNING) << "Fail to create socket for cq";
+        delete _ub_ring;
+        _ub_ring = NULL;
+        _cq_sid = INVALID_SOCKET_ID;
+        errno = saved_errno;
         return -1;
     }
     int ret = _ub_ring->UbrAllocateServerShm(remote_trx_shm, local_trx_shm);
     if (ret != 0) {
+        const int saved_errno = errno;
+        DeallocateResources();
+        delete _ub_ring;
+        _ub_ring = NULL;
+        _cq_sid = INVALID_SOCKET_ID;
+        errno = saved_errno;
         return ret;
     }
     // TODO mwj should polling start after the connection is established?
diff --git a/src/brpc/ubshm/ub_endpoint.h b/src/brpc/ubshm/ub_endpoint.h
index bf9e61c5d7..3baded0d94 100644
--- a/src/brpc/ubshm/ub_endpoint.h
+++ b/src/brpc/ubshm/ub_endpoint.h
@@ -37,6 +37,7 @@
 
 namespace brpc {
 class Socket;
+class UBShmTransport;
 namespace ubring {
 
 DECLARE_int32(ub_poller_num);
@@ -75,6 +76,7 @@ class UBConnect : public AppConnect {
 class BAIDU_CACHELINE_ALIGNMENT UBShmEndpoint : public SocketUser {
 friend class UBConnect;
 friend class Socket;
+friend class ::brpc::UBShmTransport;
 public:
     explicit UBShmEndpoint(Socket* s);
     ~UBShmEndpoint() override;
@@ -113,9 +115,6 @@ friend class Socket;
         PollerRegisterEvent(CqSidOp::REMOVE);
     }
 
-    // Callback when there is new epollin event on TCP fd
-    static void OnNewDataFromTcp(Socket* m);
-
     // Initialize polling mode
     static int PollingModeInitialize(bthread_tag_t tag,
                                      std::function<void(void)> callback,
@@ -124,33 +123,7 @@ friend class Socket;
 
     static void PollingModeRelease(bthread_tag_t tag);
 
-#ifdef UNIT_TEST
-public:
-#else
 private:
-#endif
-    enum State {
-        UNINIT = 0x0,
-        C_ALLOC_SHM = 0x1,
-        C_HELLO_SEND = 0x2,
-        C_HELLO_WAIT = 0x3,
-        C_MAP_REMOTE_SHM = 0x4,
-        C_ACK_SEND = 0x5,
-        S_HELLO_WAIT = 0x11,
-        S_ALLOC_SHM = 0x12,
-        S_HELLO_SEND = 0x13,
-        S_ACK_WAIT = 0x14,
-        ESTABLISHED = 0x100,
-        FALLBACK_TCP = 0x200,
-        FAILED = 0x300
-    };
-
-    // Process handshake at the client
-    static void* ProcessHandshakeAtClient(void* arg);
-
-    // Process handshake at the server
-    static void* ProcessHandshakeAtServer(void* arg);
-
     // Allocate resources
     // Return 0 if success, -1 if failed and errno set
     int AllocateClientResources(SHM* local_trx_shm, const char* shm_name);
@@ -160,39 +133,20 @@ friend class Socket;
     // Release resources
     void DeallocateResources();
 
-    // Read at most len bytes from fd in _socket to data
-    // wait for _read_butex if encounter EAGAIN
-    // return -1 if encounter other errno (including EOF)
-    int ReadFromFd(void* data, size_t len);
-
-
-    // Write at most len bytes from data to fd in _socket
-    // wait for _epollout_butex if encounter EAGAIN
-    // return -1 if encounter other errno
-    int WriteToFd(void* data, size_t len);
-
     // Poll CQ and get the work completion
     static void PollIn(UBShmEndpoint* ep, uint32_t ep_event);
 
     static void PollOut(UBShmEndpoint* ep, uint32_t ep_event);
 
-    // Try to read data on TCP fd in _socket
-    inline void TryReadOnTcp();
-
     // Not owner
     Socket* _socket;
     SocketId _socket_id;
 
-    State _state;
-
     // ub resource
     ubring::UBRing* _ub_ring{nullptr};
 
     SocketId _cq_sid;
 
-    // butex for inform read events on TCP fd during handshake
-    butil::atomic<int> *_read_butex;
-
     DISALLOW_COPY_AND_ASSIGN(UBShmEndpoint);
 
     struct CqSidOp {
diff --git a/src/brpc/ubshm_transport.cpp b/src/brpc/ubshm_transport.cpp
index fec1a4b646..988db16478 100644
--- a/src/brpc/ubshm_transport.cpp
+++ b/src/brpc/ubshm_transport.cpp
@@ -30,6 +30,7 @@ extern SocketVarsCollector *g_vars;
 
 void UBShmTransport::Init(Socket *socket, const SocketOptions &options) {
     CHECK(_ub_ep == NULL);
+    _handshake.Reset(socket);
     if (options.socket_mode == SOCKET_MODE_UBRING) {
         _ub_ep = new(std::nothrow)ubring::UBShmEndpoint(socket);
         if (!_ub_ep) {
@@ -47,7 +48,7 @@ void UBShmTransport::Init(Socket *socket, const SocketOptions &options) {
     _default_connect = options.app_connect;
     _on_edge_trigger = options.on_edge_triggered_events;
     if (options.need_on_edge_trigger && _on_edge_trigger == NULL) {
-        _on_edge_trigger = ubring::UBShmEndpoint::OnNewDataFromTcp;
+        _on_edge_trigger = UBShmTransport::OnNewDataFromTcp;
     }
     _tcp_transport = std::make_shared<TcpTransport>();
     _tcp_transport->Init(socket, options);
@@ -66,6 +67,7 @@ int UBShmTransport::Reset(int32_t expected_nref) {
         _ub_ep->Reset();
         _ub_state = UB_UNKNOWN;
     }
+    _handshake.Reset(_socket);
     return 0;
 }
 
@@ -77,7 +79,7 @@ std::shared_ptr<AppConnect> UBShmTransport::Connect() {
 }
 
 int UBShmTransport::CutFromIOBuf(butil::IOBuf *buf) {
-    if (_ub_ep && _ub_state != UB_OFF) {
+    if (_ub_ep && _ub_state == UB_ON) {
         butil::IOBuf *data_arr[1] = {buf};
         return _ub_ep->CutFromIOBufList(data_arr, 1);
     } else {
@@ -86,7 +88,7 @@ int UBShmTransport::CutFromIOBuf(butil::IOBuf *buf) {
 }
 
 ssize_t UBShmTransport::CutFromIOBufList(butil::IOBuf **buf, size_t ndata) {
-    if (_ub_ep && _ub_state != UB_OFF) {
+    if (_ub_ep && _ub_state == UB_ON) {
         return _ub_ep->CutFromIOBufList(buf, ndata);
     }
     return _tcp_transport->CutFromIOBufList(buf, ndata);
@@ -238,4 +240,4 @@ bool UBShmTransport::OptionsAvailableOverUB(const ServerOptions* opt) {
     return true;
 }
 } // namespace brpc
-#endif
\ No newline at end of file
+#endif
diff --git a/src/brpc/ubshm_transport.h b/src/brpc/ubshm_transport.h
index 13943d763e..4457a1cfa9 100644
--- a/src/brpc/ubshm_transport.h
+++ b/src/brpc/ubshm_transport.h
@@ -21,6 +21,7 @@
 #include "brpc/socket.h"
 #include "brpc/channel.h"
 #include "brpc/transport.h"
+#include "brpc/transport_handshake.h"
 
 namespace brpc {
 class UBShmTransport : public Transport {
@@ -28,6 +29,22 @@ class UBShmTransport : public Transport {
     friend class ubring::UBShmEndpoint;
 friend class ubring::UBConnect;
 public:
+    enum HandshakeState {
+        UNINIT = 0x0,
+        C_ALLOC_SHM = 0x1,
+        C_HELLO_SEND = 0x2,
+        C_HELLO_WAIT = 0x3,
+        C_MAP_REMOTE_SHM = 0x4,
+        C_ACK_SEND = 0x5,
+        S_HELLO_WAIT = 0x11,
+        S_ALLOC_SHM = 0x12,
+        S_HELLO_SEND = 0x13,
+        S_ACK_WAIT = 0x14,
+        ESTABLISHED = handshake::ESTABLISHED,
+        FALLBACK_TCP = handshake::FALLBACK_TCP,
+        FAILED = handshake::FAILED
+    };
+
     void Init(Socket* socket, const SocketOptions& options) override;
     void Release() override;
     int Reset(int32_t expected_nref) override;
@@ -43,6 +60,9 @@ friend class ubring::UBConnect;
         return _ub_ep;
     }
     static int ContextInitOrDie(bool serverOrNot, const void* _options);
+    static void OnNewDataFromTcp(Socket* socket);
+    static void* ProcessHandshakeAtClient(void* arg);
+    static void* ProcessHandshakeAtServer(void* arg);
 private:
     static bool OptionsAvailableForUB(const ChannelOptions* opt);
     static bool OptionsAvailableOverUB(const ServerOptions* opt);
@@ -58,7 +78,10 @@ friend class ubring::UBConnect;
     // Should use UB or not
     UBState _ub_state;
     std::shared_ptr<TcpTransport>  _tcp_transport;
+    handshake::SocketHandshakeIO _handshake;
+
+    void TryReadOnTcp();
 };
 } // namespace brpc
 #endif // BRPC_WITH_UBRING
-#endif //BRPC_UB_TRANSPORT_H
\ No newline at end of file
+#endif //BRPC_UB_TRANSPORT_H
diff --git a/test/brpc_transport_handshake_unittest.cpp b/test/brpc_transport_handshake_unittest.cpp
new file mode 100644
index 0000000000..126deb915e
--- /dev/null
+++ b/test/brpc_transport_handshake_unittest.cpp
@@ -0,0 +1,46 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <gtest/gtest.h>
+
+#include "brpc/transport_handshake.h"
+
+namespace brpc {
+namespace handshake {
+
+TEST(TransportHandshakeTest, publish_fallback_after_tcp_state) {
+    SocketHandshakeIO handshake;
+    int tcp_active = 0;
+
+    handshake.SetPhase(NEGOTIATING);
+    handshake.PublishFallback([&tcp_active]() { tcp_active = 1; });
+
+    ASSERT_EQ(1, tcp_active);
+    ASSERT_EQ(FALLBACK_TCP, handshake.phase());
+}
+
+TEST(TransportHandshakeTest, reset_clears_terminal_state) {
+    SocketHandshakeIO handshake;
+    handshake.MarkEstablished();
+    ASSERT_EQ(ESTABLISHED, handshake.phase());
+
+    handshake.Reset(NULL);
+    ASSERT_EQ(UNINITIALIZED, handshake.phase());
+}
+
+}  // namespace handshake
+}  // namespace brpc

From baf3a9e8fb2dcd8a2de561fe5eda6ddc73388f0d Mon Sep 17 00:00:00 2001
From: Gzure <740684863@qq.com>
Date: Mon, 17 Aug 2026 15:57:36 +0800
Subject: [PATCH 03/11] Add common upgrade transport handshake

---
 docs/cn/handshake_common_design.md         | 206 ++++++++++-----------
 src/brpc/input_messenger.h                 |   2 +
 src/brpc/rdma_transport.cpp                | 183 ++++++------------
 src/brpc/rdma_transport.h                  |  31 ++--
 src/brpc/socket.h                          |   2 +
 src/brpc/transport_handshake.cpp           |   2 -
 src/brpc/transport_handshake.h             |  57 ++++--
 src/brpc/ubshm/ub_endpoint.cpp             | 170 +++++------------
 src/brpc/ubshm_transport.cpp               |  86 ++++-----
 src/brpc/ubshm_transport.h                 |  22 +--
 src/brpc/upgrade_transport.cpp             | 155 ++++++++++++++++
 src/brpc/upgrade_transport.h               |  78 ++++++++
 test/brpc_transport_handshake_unittest.cpp |   7 +-
 13 files changed, 534 insertions(+), 467 deletions(-)
 create mode 100644 src/brpc/upgrade_transport.cpp
 create mode 100644 src/brpc/upgrade_transport.h

diff --git a/docs/cn/handshake_common_design.md b/docs/cn/handshake_common_design.md
index 15e680eaed..840c876ac4 100644
--- a/docs/cn/handshake_common_design.md
+++ b/docs/cn/handshake_common_design.md
@@ -114,110 +114,58 @@ Hello 中携带：
 
 ## 4. 总体架构
 
-新增公共目录：
+公共抽象放在 `src/brpc` 的 Transport 层：
 
 ```text
-src/brpc/handshake/
-    handshake_common.h       # 结果、角色、错误和阶段定义
-    handshake_io.h            # 字节流抽象
-    handshake_io.cpp
-    handshake_frame.h         # magic/长度/增量帧解析工具
-    handshake_frame.cpp
-    handshake_driver.h        # 通用握手驱动
-    handshake_driver.cpp
+src/brpc/
+    upgrade_transport.h/.cpp     # TCP-first 路由、升级成功/回退发布
+    transport_handshake.h/.cpp   # HandshakeSession 与 SocketHandshakeIO
+    rdma_transport.h/.cpp        # RDMA 协议状态机与 Endpoint adapter
+    ubshm_transport.h/.cpp       # UBSHM 协议状态机与 Endpoint adapter
 ```
 
 总体关系如下：
 
-```text
-                 +--------------------------+
-                 |     HandshakeDriver       |
-                 | client/server state flow  |
-                 +------------+-------------+
-                              |
-                 +------------v-------------+
-                 |   HandshakeProtocol       |
-                 | build/parse/validate hello|
-                 | build/parse ack           |
-                 +--+-------------+----------+
-                    |             |
-          +---------v--+     +----v---------+
-          | HandshakeIO|     | FrameCodec   |
-          | read/write |     | magic/length |
-          +---------+--+     +--------------+
-                    |
-       +------------+-------------+-------------+
-       |                          |             |
-  RDMA adapter               URMA adapter   UBSHM adapter
-```
-
-公共组件只负责握手过程和字节帧，不负责判断“创建 QP、导入 Jetty 还是映射 SHM”。
-
-## 4.1 两种候选架构对比
-
-本节同时保留两种方案，便于社区讨论握手组件应该放在哪一层。
-
-### 方案 A：公共握手组件与各类 Endpoint 组合
-
-这是上一版设计的方向：公共组件提供 `HandshakeIO`、`FrameCodec` 和部分握手驱动，各类 Transport/Endpoint 负责组合调用。TCP fallback 仍由具体 Transport 维护，Endpoint 仍可能参与握手生命周期。
-
 ```mermaid
 flowchart TB
-    Socket["Socket"] --> T["RdmaTransport / UrmaTransport / UBShmTransport"]
-    T --> TCP["TcpTransport\nTCP fallback"]
-    T --> HS["HandshakeSession\n公共握手驱动"]
-    HS --> IO["HandshakeIO / FrameCodec"]
-    HS --> EP["RdmaEndpoint / UrmaEndpoint / UBShmEndpoint"]
-    EP --> EHS["Endpoint handshake callbacks\nBuildHello / ParseHello / Negotiate"]
-    EP --> DP["高速数据面\nQP / Jetty / UBRing"]
-    T --> FB["Transport fallback state"]
-    FB --> TCP
+    S["Socket"] --> UT["UpgradeTransport\nTCP-first 路由与状态发布"]
+    UT --> TCP["TcpTransport\n默认数据面 / fallback"]
+    UT --> HS["HandshakeSession\nphase / version / lifecycle"]
+    HS --> IO["SocketHandshakeIO\nReadExact / WriteAll / readable butex"]
+    UT --> RA["RDMA adapter"]
+    UT --> UA["URMA adapter"]
+    UT --> BA["UBSHM adapter"]
+    RA --> RE["RdmaEndpoint\nQP / CQ / MR"]
+    UA --> UE["UrmaEndpoint\nJetty / JFC / Segment"]
+    BA --> BE["UBShmEndpoint\nUBRing / Shared Memory"]
 ```
 
-该方案可以先复用 frame 和 I/O 代码，改动较小；但握手生命周期仍然横跨 Transport 和 Endpoint，Endpoint 与 TCP 控制连接之间仍存在一定耦合。
+`UpgradeTransport` 决定当前数据走 TCP 还是高速 Endpoint；`HandshakeSession` 只管理一次升级尝试；具体 adapter 负责 Hello/ACK wire codec 和资源协商。Endpoint 不持有 TCP Transport，也不执行 TCP fd 读写。
 
-### 方案 B：Handshake 放到 Transport 上层，Endpoint 只负责数据面
+## 4.1 选定架构：Handshake 位于 Transport 层
 
-这是本次建议的方向：默认先建立 TCP 连接，客户端可以请求升级到 RDMA、URMA 或 UBSHM。握手、升级决策、fallback 和 active transport 选择全部由上层 Transport 负责。
+默认先建立 TCP 连接，客户端可以请求升级到 RDMA、URMA 或 UBSHM。握手、升级决策、fallback 和 active transport 选择全部由 `UpgradeTransport` 负责。
 
 ```mermaid
 flowchart TB
-    Socket["Socket"] --> UT["UpgradeTransport / NegotiatingTransport"]
+    Socket["Socket"] --> T["RdmaTransport / UrmaTransport / UBShmTransport"]
+    T -. "继承" .-> UT["UpgradeTransport"]
     UT --> TCP["TcpTransport\n默认控制面与 TCP 数据面"]
     UT --> HS["HandshakeSession\n连接协商 / 版本 / ACK / fallback"]
-    HS --> IO["HandshakeIO + FrameCodec"]
-    UT --> PF["UpgradeProvider\n选择协议与 Endpoint factory"]
-    PF --> R["RdmaEndpoint\n仅高速数据面"]
-    PF --> U["UrmaEndpoint\n仅高速数据面"]
-    PF --> B["UBShmEndpoint\n仅高速数据面"]
+    HS --> IO["SocketHandshakeIO"]
+    T --> R["RdmaEndpoint\n仅高速数据面"]
+    T --> U["UrmaEndpoint\n仅高速数据面"]
+    T --> B["UBShmEndpoint\n仅高速数据面"]
     R --> RD["QP / CQ / MR"]
     U --> UD["Jetty / JFC / Segment"]
     B --> BD["UBRing / Shared Memory"]
-    UT --> ST["TransportState\nTCP_ACTIVE / UPGRADING / HIGH_SPEED_ACTIVE"]
-    ST --> TCP
-    ST --> R
-    ST --> U
-    ST --> B
+    HS -->|"UNINITIALIZED / NEGOTIATING / FALLBACK_TCP"| TCP
+    HS -->|"ESTABLISHED"| T
 ```
 
-方案 B 中，Endpoint 不再执行 TCP fd 读写、magic 判断、握手 bthread 或 TCP fallback。它只向 Transport 提供资源准备、Hello payload、远端参数应用和数据面操作。
-
-### 两种方案的主要差异
-
-```mermaid
-flowchart LR
-    A["方案 A\nHandshake 与 Endpoint 组合"] --> A1["公共代码复用较快"]
-    A --> A2["Endpoint 仍参与连接控制"]
-    A --> A3["Fallback 状态分散"]
-    A --> A4["后续新增传输仍需接入 Endpoint 握手"]
-
-    B["方案 B\nHandshake 位于 Transport"] --> B1["TCP 是统一默认控制面"]
-    B --> B2["Endpoint 只负责高速数据面"]
-    B --> B3["Fallback 与 active path 统一"]
-    B --> B4["新增传输只需提供 Provider"]
-```
+在该架构中，Endpoint 不再执行 TCP fd 读写、magic 判断、握手 bthread 或 TCP fallback。它只向 Transport 提供资源准备、Hello payload、远端参数应用和数据面操作。
 
-## 4.2 方案 B 的连接升级时序
+## 4.2 连接升级时序
 
 ### 客户端请求高速传输
 
@@ -753,50 +701,86 @@ RDMA/URMA/UBSHM 的长度字段并不完全相同。规避：使用 `FrameSpec::
 
 实施上以当前 RDMA 握手状态机为基线：先保留 #3350 已接入的标准 server 协议解析流程，再迁移 UBSHM，最后在 URMA 分支重新基于公共接口适配。这样可以直接继承已经过社区修复和测试的 fallback 语义。
 
-## 14. 方案 B 第一版实现约束
+## 14. 当前实现边界与后续迁移
 
-第一版新增 `src/brpc/transport_handshake.*`，由 Transport 持有握手状态和 TCP 控制面 I/O：
+当前实现已经引入 `UpgradeTransport` 和 `HandshakeSession`，类关系如下：
 
 ```mermaid
-flowchart LR
-    S["Socket"] --> T["RdmaTransport / UBShmTransport"]
-    T --> TCP["TcpTransport\n默认 active / fallback"]
-    T --> H["SocketHandshakeIO\nphase + ReadExact + WriteAll"]
-    T --> E["Endpoint\n资源准备与数据面"]
-    H -->|"NEGOTIATED"| E
-    H -->|"FALLBACK_TCP"| TCP
-    E -. "不再持有 handshake state、read butex 或 TCP fd I/O" .-> T
+classDiagram
+    class Transport
+    class TcpTransport
+    class UpgradeTransport {
+        -HandshakeSession handshake
+        -TcpTransport tcp_transport
+        +CutFromIOBuf()
+        +CutFromIOBufList()
+        +WaitEpollOut()
+        +ActivateHighSpeed()
+        +FallbackToTcp()
+    }
+    class HandshakeSession {
+        -SocketHandshakeIO io
+        -atomic phase
+        -int protocol_version
+        +MarkEstablished()
+        +PublishFallback()
+        +MarkFailed()
+    }
+    class RdmaTransport
+    class UBShmTransport
+    class HighSpeedEndpoint
+
+    Transport <|-- TcpTransport
+    Transport <|-- UpgradeTransport
+    UpgradeTransport <|-- RdmaTransport
+    UpgradeTransport <|-- UBShmTransport
+    UpgradeTransport *-- TcpTransport
+    UpgradeTransport *-- HandshakeSession
+    HandshakeSession *-- SocketHandshakeIO
+    RdmaTransport --> HighSpeedEndpoint
+    UBShmTransport --> HighSpeedEndpoint
 ```
 
-具体边界如下：
+`UpgradeTransport` 是 TCP-first 的公共路由层：`UNINITIALIZED/NEGOTIATING/FALLBACK_TCP` 都走 `TcpTransport`，仅当 `HandshakeSession` release 发布 `ESTABLISHED` 后才调用高速 Endpoint 的发送与等待钩子。成功升级后的 TCP 控制连接只允许 EOF，不再接受应用数据。
 
-- `RdmaTransport` 持有 client/server 状态机；server 继续通过 #3350 引入的 bRPC 标准协议解析流程执行增量握手。
-- `UBShmTransport` 持有 client/server 状态机；`UBShmEndpoint` 只保留 SHM/ring 资源和数据面操作。后续可把 UBSHM server 固定帧接入同一标准 parser。
-- `RdmaHandshake` 仍负责 v2/v3 wire codec，但 TCP 读写改为依赖 Transport 提供的公共 `SocketHandshakeIO`，不再调用 `RdmaEndpoint::ReadFromFd/WriteToFd`。
-- origin/master 暂无受版本控制的 URMA Transport；URMA 合入或 rebase 后只需按相同边界注入 `SocketHandshakeIO` 并把状态机移到 `UrmaTransport`，不应提交本地未跟踪的旧实现。
+`HandshakeSession` 管理一次升级尝试的 phase、协议版本、fallback/established 发布顺序和 `SocketHandshakeIO`。RDMA/UBSHM 仍保留各自不同的 wire codec、协议中间阶段和资源协商，这是有意保留的 adapter 边界，不再由 Endpoint 持有。
 
-### 14.1 必须继承的修复语义
+### 14.1 当前完成度
 
-| 修复 | 公共约束 | 第一版落点 |
+| 项目 | 状态 | 说明 |
 |---|---|---|
-| #3347 | fallback 状态必须原子发布，事件线程用 acquire 读取 | `SocketHandshakeIO::PublishFallback/phase` |
-| #3406 | 必须先发布 Transport 的 TCP active/off 状态，再 release 发布 `FALLBACK_TCP` | `PublishFallback` 回调先执行，随后 release store |
-| #3424 | 高速资源准备失败是可降级错误；清理部分资源并保持 TCP 可用 | RDMA 保留事务式 `AllocateResources`；UBSHM 失败路径补充资源清理 |
+| TCP-first 路由 | 已实现 | RDMA/UBSHM 共同继承 `UpgradeTransport`，不再各自持有 `TcpTransport` |
+| 公共握手生命周期 | 已实现 | `HandshakeSession` 统一 phase、version、I/O 和终态发布 |
+| RDMA client/server | 已迁移 | server 保留 #3350 的 bRPC 标准协议增量解析流程 |
+| UBSHM client/server | 部分迁移 | 生命周期已进入 Transport；server 固定帧仍由握手 bthread 读取，后续迁移到标准 parser |
+| URMA | 待迁移 | origin/master 暂无受版本控制的 URMA Transport；合入后实现 `UpgradeTransport` 的数据面钩子并复用 `HandshakeSession` |
+| 通用 FrameCodec/Protocol adapter | 待实现 | 当前先复用 RDMA 已验证的 v2/v3 codec，避免一次改动 wire format 与 Transport 生命周期 |
+
+### 14.2 必须继承的修复语义
+
+| 修复 | 公共约束 | 落点 |
+|---|---|---|
+| #3347 | fallback 状态必须原子发布，事件线程用 acquire 读取 | `HandshakeSession::PublishFallback/phase` |
+| #3406 | 必须先发布 Transport 的 TCP active/off 状态，再 release 发布 `FALLBACK_TCP` | `UpgradeTransport::FallbackToTcp` 调整 provider 状态后发布终态 |
+| #3424 | 高速资源准备失败是可降级错误；清理部分资源并保持 TCP 可用 | RDMA 保留事务式 `AllocateResources`；失败后由公共 fallback 路径恢复 TCP |
 | #3425 | CQ re-arm 后同时补 poll send/recv CQ | 保留在 RDMA Endpoint 数据面，不移入握手组件 |
 | #3427 | 外部 Bazel workspace 下生成规则不能依赖主仓布局 | 公共实现不新增 proto；源码通过现有递归 glob 收录 |
 
-### 14.2 状态发布规则
+### 14.3 状态发布规则
 
-成功升级和回退只能由 Transport 发布：
+成功升级和回退只能由 `UpgradeTransport` 发布：
 
 ```cpp
-// Fallback: publish TCP selection first, then release-publish terminal phase.
-handshake.PublishFallback([transport]() {
-    transport->SetHighSpeedOff();
-});
-
-// Success: all endpoint resources are ready before publishing ESTABLISHED.
-handshake.MarkEstablished();
+void UpgradeTransport::FallbackToTcp() {
+    handshake.PublishFallback([this]() {
+        SetHighSpeedAvailable(false);
+    });
+}
+
+void UpgradeTransport::ActivateHighSpeed() {
+    SetHighSpeedAvailable(true);
+    handshake.MarkEstablished();
+}
 ```
 
-事件线程必须通过 acquire load 读取 phase。看到 `FALLBACK_TCP` 后可以直接恢复 `InputMessenger`；看到 `ESTABLISHED` 后才允许发送和接收高速数据。`UNKNOWN/NEGOTIATING` 状态不得路由到 Endpoint 数据面。
+事件线程必须通过 acquire load 读取 phase。看到 `FALLBACK_TCP` 后可以直接恢复 `InputMessenger`；看到 `ESTABLISHED` 后才允许发送和接收高速数据。`UNINITIALIZED/NEGOTIATING` 状态不得路由到 Endpoint 数据面。
diff --git a/src/brpc/input_messenger.h b/src/brpc/input_messenger.h
index e82ecd4a66..f9d8881703 100644
--- a/src/brpc/input_messenger.h
+++ b/src/brpc/input_messenger.h
@@ -34,6 +34,7 @@ class UBShmEndpoint;
 }
 class TcpTransport;
 class RdmaTransport;
+class UpgradeTransport;
 struct InputMessageHandler {
     // The callback to cut a message from `source'.
     // Returned message will be passed to process_request or process_response
@@ -97,6 +98,7 @@ class InputMessenger : public SocketUser {
 friend class Socket;
 friend class TcpTransport;
 friend class RdmaTransport;
+friend class UpgradeTransport;
 friend class rdma::RdmaEndpoint;
 friend class ubring::UBShmEndpoint;
 public:
diff --git a/src/brpc/rdma_transport.cpp b/src/brpc/rdma_transport.cpp
index e82ac325a5..562ef29ce5 100644
--- a/src/brpc/rdma_transport.cpp
+++ b/src/brpc/rdma_transport.cpp
@@ -17,12 +17,9 @@
 
 #if BRPC_WITH_RDMA
 
-#include <unistd.h>
-
 #include "brpc/rdma_transport.h"
 #include "butil/sys_byteorder.h"
 #include "brpc/event_dispatcher.h"
-#include "brpc/tcp_transport.h"
 #include "brpc/input_messenger.h"
 #include "brpc/rdma/rdma_endpoint.h"
 #include "brpc/rdma/rdma_handshake.h"
@@ -51,9 +48,7 @@ void RdmaConnect::StartConnect(const Socket* socket,
         return;
     }
     if (!IsRdmaAvailable()) {
-        transport->_handshake.PublishFallback([transport]() {
-            transport->_rdma_state = RdmaTransport::RDMA_OFF;
-        });
+        transport->FallbackToTcp();
         done(0, data);
         return;
     }
@@ -80,49 +75,6 @@ void RdmaConnect::Run() {
 
 }  // namespace rdma
 
-void RdmaTransport::OnNewDataFromTcp(Socket* socket) {
-    RdmaTransport* transport =
-        static_cast<RdmaTransport*>(socket->_transport.get());
-    CHECK(transport->_rdma_ep != NULL);
-
-    int progress = Socket::PROGRESS_INIT;
-    while (true) {
-        // Acquire pairs with PublishFallback's release store. In particular,
-        // RDMA_OFF is visible before InputMessenger resumes TCP parsing.
-        const int state = transport->_handshake.phase();
-        if (state == UNINIT) {
-            // The client handshake bthread has not started yet.
-        } else if (state < ESTABLISHED) {
-            transport->_handshake.NotifyReadable();
-        } else if (state == FALLBACK_TCP) {
-            InputMessenger::OnNewMessages(socket);
-            return;
-        } else if (state == ESTABLISHED) {
-            uint8_t byte;
-            const ssize_t nr = read(socket->fd(), &byte, 1);
-            if (nr == 0) {
-                socket->SetEOF();
-                return;
-            }
-            if (nr > 0) {
-                socket->SetFailed(EPROTO, "Read unexpected data from %s",
-                                  socket->description().c_str());
-                return;
-            }
-            if (errno != EAGAIN) {
-                const int saved_errno = errno;
-                socket->SetFailed(saved_errno, "Fail to read from %s: %s",
-                                  socket->description().c_str(),
-                                  berror(saved_errno));
-                return;
-            }
-        }
-        if (!socket->MoreReadEvents(&progress)) {
-            break;
-        }
-    }
-}
-
 void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
     RdmaTransport* transport = static_cast<RdmaTransport*>(arg);
     rdma::RdmaEndpoint* ep = transport->_rdma_ep;
@@ -134,9 +86,9 @@ void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
         << "Start handshake on " << socket->description();
 
     std::unique_ptr<rdma::RdmaHandshake> handshake =
-        rdma::CreateClientHandshake(ep, &transport->_handshake);
+        rdma::CreateClientHandshake(ep, transport->_handshake.io());
     CHECK(handshake != NULL);
-    transport->_handshake_version = handshake->ProtocolVersion();
+    transport->_handshake.set_protocol_version(handshake->ProtocolVersion());
 
     transport->_handshake.SetPhase(C_ALLOC_QPCQ);
     if (ep->AllocateResources() < 0) {
@@ -145,9 +97,7 @@ void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
         // Resource preparation is transactional (see #3424): partial RDMA
         // resources are cleaned by AllocateResources and TCP remains usable.
         errno = 0;
-        transport->_handshake.PublishFallback([transport]() {
-            transport->_rdma_state = RDMA_OFF;
-        });
+        transport->FallbackToTcp();
         return NULL;
     }
 
@@ -157,7 +107,7 @@ void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
         socket->SetFailed(saved_errno,
                           "Fail to complete rdma handshake from %s: %s",
                           socket->description().c_str(), berror(saved_errno));
-        transport->_handshake.MarkFailed();
+        transport->FailHandshake();
         return NULL;
     }
 
@@ -170,7 +120,7 @@ void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
         socket->SetFailed(saved_errno,
                           "Fail to complete rdma handshake from %s: %s",
                           socket->description().c_str(), berror(saved_errno));
-        transport->_handshake.MarkFailed();
+        transport->FailHandshake();
         return NULL;
     }
 
@@ -192,25 +142,24 @@ void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
     const bool rdma_on = transport->_rdma_state == RDMA_ON;
     const uint32_t flags_be = butil::HostToNet32(
         rdma_on ? rdma::HELLO_ACK_RDMA_OK : 0);
-    if (transport->_handshake.WriteAll(&flags_be, rdma::HELLO_ACK_LEN) < 0) {
+    if (transport->_handshake.io()->WriteAll(
+            &flags_be, rdma::HELLO_ACK_LEN) < 0) {
         const int saved_errno = errno;
         socket->SetFailed(saved_errno,
                           "Fail to complete rdma handshake from %s: %s",
                           socket->description().c_str(), berror(saved_errno));
-        transport->_handshake.MarkFailed();
+        transport->FailHandshake();
         return NULL;
     }
 
     if (rdma_on) {
-        transport->_handshake.MarkEstablished();
+        transport->ActivateHighSpeed();
         LOG_IF(INFO, rdma::FLAGS_rdma_trace_verbose)
             << "Client handshake ends (use rdma v"
-            << transport->_handshake_version << ") on "
+            << transport->handshake_version() << ") on "
             << socket->description();
     } else {
-        transport->_handshake.PublishFallback([transport]() {
-            transport->_rdma_state = RDMA_OFF;
-        });
+        transport->FallbackToTcp();
         LOG_IF(INFO, rdma::FLAGS_rdma_trace_verbose)
             << "Client handshake ends (use tcp) on " << socket->description();
     }
@@ -233,11 +182,11 @@ ParseResult RdmaTransport::ExecuteServerHandshake(butil::IOBuf* source,
         CHECK_EQ(source->copy_to(magic, sizeof(magic)), sizeof(magic));
         std::unique_ptr<rdma::RdmaHandshake> handshake =
             rdma::CreateServerHandshakeByMagic(
-                ep, &transport->_handshake, source, magic);
+                ep, transport->_handshake.io(), source, magic);
         if (handshake == NULL) {
             return MakeParseError(PARSE_ERROR_TRY_OTHERS);
         }
-        transport->_handshake_version = handshake->ProtocolVersion();
+        transport->_handshake.set_protocol_version(handshake->ProtocolVersion());
         transport->_handshake.SetPhase(S_HELLO_WAIT);
 
         rdma::ParsedHello remote{};
@@ -247,7 +196,7 @@ ParseResult RdmaTransport::ExecuteServerHandshake(butil::IOBuf* source,
             return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
         }
         if (result == rdma::RemoteHelloResult::ERROR) {
-            transport->_handshake.MarkFailed();
+            transport->FailHandshake();
             return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
         }
 
@@ -272,7 +221,7 @@ ParseResult RdmaTransport::ExecuteServerHandshake(butil::IOBuf* source,
 
         transport->_handshake.SetPhase(S_HELLO_SEND);
         if (handshake->SendLocalHello() < 0) {
-            transport->_handshake.MarkFailed();
+            transport->FailHandshake();
             return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
         }
         socket->reset_parsing_context(rdma::ServerHandshakeContext::Create());
@@ -291,9 +240,7 @@ ParseResult RdmaTransport::ExecuteServerHandshake(butil::IOBuf* source,
     if (!client_ack_ok) {
         // Keep any coalesced RPC bytes in source. After the release-published
         // fallback, InputMessenger will continue parsing them as TCP data.
-        transport->_handshake.PublishFallback([transport]() {
-            transport->_rdma_state = RDMA_OFF;
-        });
+        transport->FallbackToTcp();
         socket->reset_parsing_context(NULL);
         return MakeParseError(PARSE_ERROR_TRY_OTHERS);
     }
@@ -301,27 +248,24 @@ ParseResult RdmaTransport::ExecuteServerHandshake(butil::IOBuf* source,
     if (!source->empty()) {
         // A successful RDMA upgrade must not carry application bytes on the
         // TCP control connection after the ACK.
-        transport->_handshake.MarkFailed();
+        transport->FailHandshake();
         socket->reset_parsing_context(NULL);
         return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
     }
 
     if (transport->_rdma_state == RDMA_OFF) {
-        transport->_handshake.MarkFailed();
+        transport->FailHandshake();
         socket->reset_parsing_context(NULL);
         return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
     }
 
-    transport->_rdma_state = RDMA_ON;
-    transport->_handshake.MarkEstablished();
+    transport->ActivateHighSpeed();
     socket->reset_parsing_context(NULL);
     return MakeParseError(PARSE_ERROR_TRY_OTHERS);
 }
 
 void RdmaTransport::Init(Socket *socket, const SocketOptions &options) {
     CHECK(_rdma_ep == NULL);
-    _handshake.Reset(socket);
-    _handshake_version = 0;
     if (options.socket_mode == SOCKET_MODE_RDMA) {
         _rdma_ep = new(std::nothrow)rdma::RdmaEndpoint(socket);
         if (!_rdma_ep) {
@@ -335,23 +279,20 @@ void RdmaTransport::Init(Socket *socket, const SocketOptions &options) {
         _rdma_state = RDMA_OFF;
         socket->_socket_mode = SOCKET_MODE_TCP;
     }
-    _socket = socket;
-    _default_connect = options.app_connect;
-    _on_edge_trigger = options.on_edge_triggered_events;
-    if (options.need_on_edge_trigger && _on_edge_trigger == NULL) {
+    OnEdgeTrigger default_on_edge;
+    if (options.need_on_edge_trigger) {
         // Server-side RDMA sockets drive the handshake through the standard
         // InputMessenger path (ParseRdmaHandshake), so they use OnNewMessages
         // just like TCP sockets. Only client-side sockets, whose handshake
         // ProcessHandshakeAtClient is an active blocking bthread relying on
-        // SocketHandshakeIO being woken by OnNewDataFromTcp.
+        // HandshakeSession being woken by OnNewDataFromTcp.
         if (options.user == static_cast<SocketUser*>(get_client_side_messenger())) {
-            _on_edge_trigger = RdmaTransport::OnNewDataFromTcp;
+            default_on_edge = UpgradeTransport::OnNewDataFromTcp;
         } else {
-            _on_edge_trigger = InputMessenger::OnNewMessages;
+            default_on_edge = InputMessenger::OnNewMessages;
         }
     }
-    _tcp_transport = std::make_shared<TcpTransport>();
-    _tcp_transport->Init(socket, options);
+    InitUpgradeTransport(socket, options, default_on_edge);
 }
 
 void RdmaTransport::Release() {
@@ -367,8 +308,7 @@ int RdmaTransport::Reset(int32_t expected_nref) {
         _rdma_ep->Reset();
         _rdma_state = RDMA_UNKNOWN;
     }
-    _handshake.Reset(_socket);
-    _handshake_version = 0;
+    ResetUpgradeTransport();
     return 0;
 }
 
@@ -379,54 +319,37 @@ std::shared_ptr<AppConnect> RdmaTransport::Connect() {
     return _default_connect;
 }
 
-int RdmaTransport::CutFromIOBuf(butil::IOBuf *buf) {
-    // Only send over the RDMA channel once the handshake has NEGOTIATED it
-    // (RDMA_ON). While the state is still RDMA_UNKNOWN (handshake in progress,
-    // or a server connection that turned out to be plain TCP and never
-    // handshook) or RDMA_OFF (fell back), the QP is not usable and everything
-    // must go over the TCP fd. Mirrors the RDMA_ON check in WaitEpollOut().
-    if (_rdma_ep && _rdma_state == RDMA_ON) {
-        butil::IOBuf *data_arr[1] = {buf};
-        return _rdma_ep->CutFromIOBufList(data_arr, 1);
-    } else {
-        return _tcp_transport->CutFromIOBuf(buf);
-    }
+void RdmaTransport::SetHighSpeedAvailable(bool available) {
+    _rdma_state = available ? RDMA_ON : RDMA_OFF;
 }
 
-ssize_t RdmaTransport::CutFromIOBufList(butil::IOBuf **buf, size_t ndata) {
-    if (_rdma_ep && _rdma_state == RDMA_ON) {
-        return _rdma_ep->CutFromIOBufList(buf, ndata);
-    }
-    return _tcp_transport->CutFromIOBufList(buf, ndata);
+ssize_t RdmaTransport::CutFromHighSpeedIOBufList(
+    butil::IOBuf** buf, size_t ndata) {
+    CHECK(_rdma_ep != NULL);
+    return _rdma_ep->CutFromIOBufList(buf, ndata);
 }
 
-int RdmaTransport::WaitEpollOut(butil::atomic<int> *_epollout_butex,
-                                    bool pollin, const timespec duetime) {
-    if (_rdma_state == RDMA_ON) {
-        const int expected_val = _epollout_butex->load(butil::memory_order_acquire);
-        CHECK(_rdma_ep != NULL);
-        if (!_rdma_ep->IsWritable()) {
-            g_vars->nwaitepollout << 1;
-            if (bthread::butex_wait(_epollout_butex, expected_val, &duetime) < 0) {
-                if (errno != EAGAIN && errno != ETIMEDOUT) {
-                    const int saved_errno = errno;
-                    PLOG(WARNING) << "Fail to wait rdma window of " << _socket;
-                    _socket->SetFailed(saved_errno,
-                                       "Fail to wait rdma window of %s: %s",
-                                       _socket->description().c_str(),
-                                       berror(saved_errno));
-                }
-                if (_socket->Failed()) {
-                    // NOTE:
-                    // Different from TCP, we cannot find the RDMA channel
-                    // failed by writing to it. Thus we must check if it
-                    // is already failed here.
-                    return 1;
-                }
+int RdmaTransport::WaitHighSpeedEpollOut(
+    butil::atomic<int>* epollout_butex, bool, timespec duetime) {
+    const int expected_val = epollout_butex->load(butil::memory_order_acquire);
+    CHECK(_rdma_ep != NULL);
+    if (!_rdma_ep->IsWritable()) {
+        g_vars->nwaitepollout << 1;
+        if (bthread::butex_wait(epollout_butex, expected_val, &duetime) < 0) {
+            if (errno != EAGAIN && errno != ETIMEDOUT) {
+                const int saved_errno = errno;
+                PLOG(WARNING) << "Fail to wait rdma window of " << _socket;
+                _socket->SetFailed(saved_errno,
+                                   "Fail to wait rdma window of %s: %s",
+                                   _socket->description().c_str(),
+                                   berror(saved_errno));
+            }
+            if (_socket->Failed()) {
+                // Unlike TCP, writing cannot discover an already failed RDMA
+                // channel, so check the Socket failure here.
+                return 1;
             }
         }
-    } else {
-        return _tcp_transport->WaitEpollOut(_epollout_butex, pollin, duetime);
     }
     return 0;
 }
@@ -503,7 +426,7 @@ void RdmaTransport::Debug(std::ostream &os) {
     case FAILED: state = "FAILED"; break;
     }
     os << "\nhandshake_state=" << state
-       << "\nhandshake_version=" << _handshake_version;
+       << "\nhandshake_version=" << handshake_version();
 }
 
 int RdmaTransport::ContextInitOrDie(bool serverOrNot, const void* _options) {
diff --git a/src/brpc/rdma_transport.h b/src/brpc/rdma_transport.h
index db955f5b34..2031c2cbac 100644
--- a/src/brpc/rdma_transport.h
+++ b/src/brpc/rdma_transport.h
@@ -21,16 +21,15 @@
 #if BRPC_WITH_RDMA
 #include "brpc/socket.h"
 #include "brpc/channel.h"
-#include "brpc/transport.h"
-#include "brpc/transport_handshake.h"
+#include "brpc/upgrade_transport.h"
 
 namespace brpc {
-class RdmaTransport : public Transport {
-friend class TransportFactory;
-friend class rdma::RdmaEndpoint;
-friend class rdma::RdmaConnect;
-friend class rdma::RdmaHandshakeServerV2;
-friend class rdma::RdmaHandshakeServerV3;
+class RdmaTransport : public UpgradeTransport {
+    friend class TransportFactory;
+    friend class rdma::RdmaEndpoint;
+    friend class rdma::RdmaConnect;
+    friend class rdma::RdmaHandshakeServerV2;
+    friend class rdma::RdmaHandshakeServerV3;
 public:
     enum HandshakeState {
         UNINIT = 0x0,
@@ -53,9 +52,6 @@ friend class rdma::RdmaHandshakeServerV3;
     void Release() override;
     int Reset(int32_t expected_nref) override;
     std::shared_ptr<AppConnect> Connect() override;
-    int CutFromIOBuf(butil::IOBuf* buf) override;
-    ssize_t CutFromIOBufList(butil::IOBuf** buf, size_t ndata) override;
-    int WaitEpollOut(butil::atomic<int>* _epollout_butex, bool pollin, const timespec duetime) override;
     void ProcessEvent(bthread_attr_t attr) override;
     void QueueMessage(InputMessageClosure& inputMsg, int* num_bthread_created, bool last_msg) override;
     void Debug(std::ostream &os) override;
@@ -63,18 +59,20 @@ friend class rdma::RdmaHandshakeServerV3;
         CHECK(_rdma_ep != NULL);
         return _rdma_ep;
     }
-    int handshake_phase() const {
-        return _handshake.phase();
-    }
     static int ContextInitOrDie(bool serverOrNot, const void* _options);
 
     // TCP control-plane callbacks. The endpoint is intentionally absent from
     // these entry points and only participates through resource operations.
-    static void OnNewDataFromTcp(Socket* socket);
     static void* ProcessHandshakeAtClient(void* arg);
     static ParseResult ExecuteServerHandshake(butil::IOBuf* source,
                                               Socket* socket);
 private:
+    void SetHighSpeedAvailable(bool available) override;
+    ssize_t CutFromHighSpeedIOBufList(
+        butil::IOBuf** buf, size_t ndata) override;
+    int WaitHighSpeedEpollOut(butil::atomic<int>* epollout_butex,
+                              bool pollin, timespec duetime) override;
+
     static bool OptionsAvailableForRdma(const ChannelOptions* opt);
     static bool OptionsAvailableOverRdma(const ServerOptions* opt);
 
@@ -88,9 +86,6 @@ friend class rdma::RdmaHandshakeServerV3;
     rdma::RdmaEndpoint* _rdma_ep = NULL;
     // Should use RDMA or not
     RdmaState _rdma_state;
-    std::shared_ptr<TcpTransport>  _tcp_transport;
-    handshake::SocketHandshakeIO _handshake;
-    int _handshake_version = 0;
 };
 } // namespace brpc
 #endif // BRPC_WITH_RDMA
diff --git a/src/brpc/socket.h b/src/brpc/socket.h
index 3bc90918d9..529f1d8777 100644
--- a/src/brpc/socket.h
+++ b/src/brpc/socket.h
@@ -70,6 +70,7 @@ class AuthContext;
 class EventDispatcher;
 class Stream;
 class Transport;
+class UpgradeTransport;
 
 // Set SO_SNDBUF/SO_RCVBUF according to socket_*_buffer_size flags.
 void SetSocketBufferOptions(int fd);
@@ -342,6 +343,7 @@ friend class VersionedRefWithId<Socket>;
 friend class IOEvent<Socket>;
 friend void DereferenceSocket(Socket*);
 friend class Transport;
+friend class UpgradeTransport;
 friend class TcpTransport;
 friend class RdmaTransport;
 friend class TransportFactory;
diff --git a/src/brpc/transport_handshake.cpp b/src/brpc/transport_handshake.cpp
index 934dca6a6b..56ef518ff9 100644
--- a/src/brpc/transport_handshake.cpp
+++ b/src/brpc/transport_handshake.cpp
@@ -43,7 +43,6 @@ static const int WAIT_TIMEOUT_MS = 50;
 
 SocketHandshakeIO::SocketHandshakeIO(Socket* socket)
     : _socket(socket)
-    , _phase(UNINITIALIZED)
     , _read_butex(bthread::butex_create_checked<butil::atomic<int> >()) {
 }
 
@@ -53,7 +52,6 @@ SocketHandshakeIO::~SocketHandshakeIO() {
 
 void SocketHandshakeIO::Reset(Socket* socket) {
     _socket = socket;
-    _phase.store(UNINITIALIZED, butil::memory_order_relaxed);
 }
 
 void SocketHandshakeIO::NotifyReadable() {
diff --git a/src/brpc/transport_handshake.h b/src/brpc/transport_handshake.h
index 03e4cb9f53..0161b655dc 100644
--- a/src/brpc/transport_handshake.h
+++ b/src/brpc/transport_handshake.h
@@ -39,7 +39,7 @@ struct ServerHandshakeContext : public Destroyable {
 };
 
 // Protocol adapters may use transport-specific intermediate values, but the
-// terminal values are shared so that the TCP event callback can make the same
+// terminal values are shared so that UpgradeTransport can make the same
 // acquire-side decision for RDMA, URMA and UBSHM.
 enum Phase {
     UNINITIALIZED = 0,
@@ -49,9 +49,8 @@ enum Phase {
     FAILED = 0x300,
 };
 
-// Owns all TCP-fd I/O and synchronization used while upgrading a connection.
-// High-speed endpoints deliberately do not own this object: they only prepare
-// and activate protocol-specific data-plane resources.
+// Owns TCP-fd I/O and its readable notification while upgrading a connection.
+// The handshake lifecycle is owned by HandshakeSession below.
 class SocketHandshakeIO {
 public:
     explicit SocketHandshakeIO(Socket* socket = NULL);
@@ -59,6 +58,36 @@ class SocketHandshakeIO {
 
     void Reset(Socket* socket);
 
+    void NotifyReadable();
+
+    // Read/write exactly len bytes. EAGAIN is handled by waiting for the
+    // socket event callback; EOF is reported as EEOF.
+    int ReadExact(void* data, size_t len);
+    int ReadExact(butil::IOPortal* data, size_t len);
+    int WriteAll(const void* data, size_t len);
+    int WriteAll(butil::IOBuf* data);
+
+private:
+    Socket* _socket;
+    butil::atomic<int>* _read_butex;
+
+    DISALLOW_COPY_AND_ASSIGN(SocketHandshakeIO);
+};
+
+// Owns one connection-upgrade attempt. Wire codecs and endpoint resource
+// operations remain protocol adapters, while this class provides the common
+// lifecycle, publication ordering and TCP control-plane I/O.
+class HandshakeSession {
+public:
+    explicit HandshakeSession(Socket* socket = NULL)
+        : _io(socket), _phase(UNINITIALIZED), _protocol_version(0) {}
+
+    void Reset(Socket* socket) {
+        _io.Reset(socket);
+        _protocol_version = 0;
+        _phase.store(UNINITIALIZED, butil::memory_order_relaxed);
+    }
+
     int phase(butil::memory_order order = butil::memory_order_acquire) const {
         return _phase.load(order);
     }
@@ -67,6 +96,9 @@ class SocketHandshakeIO {
         _phase.store(phase, butil::memory_order_relaxed);
     }
 
+    int protocol_version() const { return _protocol_version; }
+    void set_protocol_version(int version) { _protocol_version = version; }
+
     void MarkEstablished() {
         _phase.store(ESTABLISHED, butil::memory_order_release);
     }
@@ -85,21 +117,16 @@ class SocketHandshakeIO {
         _phase.store(FALLBACK_TCP, butil::memory_order_release);
     }
 
-    void NotifyReadable();
-
-    // Read/write exactly len bytes. EAGAIN is handled by waiting for the
-    // socket event callback; EOF is reported as EEOF.
-    int ReadExact(void* data, size_t len);
-    int ReadExact(butil::IOPortal* data, size_t len);
-    int WriteAll(const void* data, size_t len);
-    int WriteAll(butil::IOBuf* data);
+    SocketHandshakeIO* io() { return &_io; }
+    const SocketHandshakeIO* io() const { return &_io; }
+    void NotifyReadable() { _io.NotifyReadable(); }
 
 private:
-    Socket* _socket;
+    SocketHandshakeIO _io;
     butil::atomic<int> _phase;
-    butil::atomic<int>* _read_butex;
+    int _protocol_version;
 
-    DISALLOW_COPY_AND_ASSIGN(SocketHandshakeIO);
+    DISALLOW_COPY_AND_ASSIGN(HandshakeSession);
 };
 
 }  // namespace handshake
diff --git a/src/brpc/ubshm/ub_endpoint.cpp b/src/brpc/ubshm/ub_endpoint.cpp
index 39ff83800e..fe2138fd7c 100644
--- a/src/brpc/ubshm/ub_endpoint.cpp
+++ b/src/brpc/ubshm/ub_endpoint.cpp
@@ -151,9 +151,7 @@ void UBConnect::StartConnect(const Socket* socket,
         return;
     }
     if (!IsUBAvailable()) {
-        ub_transport->_handshake.PublishFallback([ub_transport]() {
-            ub_transport->_ub_state = UBShmTransport::UB_OFF;
-        });
+        ub_transport->FallbackToTcp();
         done(0, data);
         return;
     }
@@ -183,80 +181,23 @@ void UBConnect::Run() {
 // while the connection-control state machine belongs to the Transport layer.
 using namespace ubring;
 
-static void TryReadOnTcpDuringUbEst(Socket* s) {
-    int progress = Socket::PROGRESS_INIT;
-    while (true) {
-        uint8_t tmp;
-        ssize_t nr = read(s->fd(), &tmp, 1);
-        if (nr < 0) {
-            if (errno != EAGAIN) {
-                const int saved_errno = errno;
-                PLOG(WARNING) << "Fail to read from " << s;
-                s->SetFailed(saved_errno, "Fail to read from %s: %s",
-                        s->description().c_str(), berror(saved_errno));
-                return;
-            }
-            if (!s->MoreReadEvents(&progress)) {
-                break;
-            }
-        } else if (nr == 0) {
-            s->SetEOF();
-            return;
-        } else {
-            LOG(WARNING) << "Read unexpected data from " << s;
-            s->SetFailed(EPROTO, "Read unexpected data from %s",
-                    s->description().c_str());
-            return;
-        }
+void UBShmTransport::StartServerHandshake() {
+    if (!IsUBAvailable()) {
+        FallbackToTcp();
+        return;
     }
-}
-
-void UBShmTransport::OnNewDataFromTcp(Socket* m) {
-    auto* ub_transport = static_cast<UBShmTransport*>(m->_transport.get());
-    UBShmEndpoint* ep = ub_transport->GetUBShmEp();
-    CHECK(ep != NULL);
-
-    int progress = Socket::PROGRESS_INIT;
-    while (true) {
-        const int state = ub_transport->_handshake.phase();
-        if (state == UNINIT) {
-            if (!m->CreatedByConnect()) {
-                if (!IsUBAvailable()) {
-                    ub_transport->_handshake.PublishFallback([ub_transport]() {
-                        ub_transport->_ub_state = UBShmTransport::UB_OFF;
-                    });
-                    continue;
-                }
-                bthread_t tid;
-                ub_transport->_handshake.SetPhase(S_HELLO_WAIT);
-                SocketUniquePtr s;
-                m->ReAddress(&s);
-                bthread_attr_t attr = BTHREAD_ATTR_NORMAL;
-                bthread_attr_set_name(&attr, "UBProcessHandshakeAtServer");
-                if (bthread_start_background(&tid, &attr,
-                            ProcessHandshakeAtServer, ub_transport) < 0) {
-                    ub_transport->_handshake.SetPhase(UNINIT);
-                    LOG(FATAL) << "Fail to start handshake bthread";
-                } else {
-                    s.release();
-                }
-            } else {
-                // The connection may be closed or reset before the client
-                // starts handshake. This will be handled by client handshake.
-                // Ignore the exception here.
-            }
-        } else if (state < ESTABLISHED) {  // during handshake
-            ub_transport->_handshake.NotifyReadable();
-        } else if (state == FALLBACK_TCP){  // handshake finishes
-            InputMessenger::OnNewMessages(m);
-            return;
-        } else if (state == ESTABLISHED) {
-            TryReadOnTcpDuringUbEst(ep->_socket);
-            return;
-        }
-        if (!m->MoreReadEvents(&progress)) {
-            break;
-        }
+    bthread_t tid;
+    _handshake.SetPhase(S_HELLO_WAIT);
+    SocketUniquePtr socket;
+    _socket->ReAddress(&socket);
+    bthread_attr_t attr = BTHREAD_ATTR_NORMAL;
+    bthread_attr_set_name(&attr, "UBProcessHandshakeAtServer");
+    if (bthread_start_background(
+            &tid, &attr, ProcessHandshakeAtServer, this) < 0) {
+        _handshake.SetPhase(UNINIT);
+        LOG(FATAL) << "Fail to start handshake bthread";
+    } else {
+        socket.release();
     }
 }
 bool HelloNegotiationValid(HelloMessage& msg) {
@@ -268,17 +209,6 @@ bool HelloNegotiationValid(HelloMessage& msg) {
     return false;
 }
 
-void UBShmTransport::TryReadOnTcp() {
-    if (_socket->_nevent.fetch_add(1, butil::memory_order_acq_rel) == 0) {
-        const int state = _handshake.phase();
-        if (state == FALLBACK_TCP) {
-            InputMessenger::OnNewMessages(_socket);
-        } else if (state == ESTABLISHED) {
-            TryReadOnTcpDuringUbEst(_socket);
-        }
-    }
-}
-
 void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
     UBShmTransport* ub_transport = static_cast<UBShmTransport*>(arg);
     UBShmEndpoint* ep = ub_transport->_ub_ep;
@@ -298,9 +228,7 @@ void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
     if (ep->AllocateClientResources(&local_trx_shm, shm_name) < 0) {
         LOG(WARNING) << "Fallback to tcp:" << s->description();
         errno = 0;
-        ub_transport->_handshake.PublishFallback([ub_transport]() {
-            ub_transport->_ub_state = UBShmTransport::UB_OFF;
-        });
+        ub_transport->FallbackToTcp();
         return NULL;
     }
 
@@ -313,40 +241,42 @@ void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
     memcpy(local_msg.shm_name, local_trx_shm.name, SHM_MAX_NAME_BUFF_LEN);
     memcpy(data, MAGIC_STR, MAGIC_STR_LEN);
     local_msg.Serialize((char*)data + MAGIC_STR_LEN);
-    if (ub_transport->_handshake.WriteAll(data, g_ub_hello_msg_len) < 0) {
+    if (ub_transport->_handshake.io()->WriteAll(
+            data, g_ub_hello_msg_len) < 0) {
         const int saved_errno = errno;
         PLOG(WARNING) << "Fail to send hello message to server:" << s->description();
         s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(saved_errno));
-        ub_transport->_handshake.MarkFailed();
+        ub_transport->FailHandshake();
         return NULL;
     }
     LOG_IF(INFO, FLAGS_ub_trace_verbose) << "client handshake message : " << local_msg.toString();
 
     ub_transport->_handshake.SetPhase(C_HELLO_WAIT);
-    if (ub_transport->_handshake.ReadExact(data, MAGIC_STR_LEN) < 0) {
+    if (ub_transport->_handshake.io()->ReadExact(
+            data, MAGIC_STR_LEN) < 0) {
         const int saved_errno = errno;
         PLOG(WARNING) << "Fail to get hello message from server:" << s->description();
         s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(saved_errno));
-        ub_transport->_handshake.MarkFailed();
+        ub_transport->FailHandshake();
         return NULL;
     }
     if (memcmp(data, MAGIC_STR, MAGIC_STR_LEN) != 0) {
         LOG(WARNING) << "Read unexpected data during handshake:" << s->description();
         s->SetFailed(EPROTO, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(EPROTO));
-        ub_transport->_handshake.MarkFailed();
+        ub_transport->FailHandshake();
         return NULL;
     }
 
-    if (ub_transport->_handshake.ReadExact(
+    if (ub_transport->_handshake.io()->ReadExact(
             data, HELLO_MSG_LEN_MIN - MAGIC_STR_LEN) < 0) {
         const int saved_errno = errno;
         PLOG(WARNING) << "Fail to get Hello Message from server:" << s->description();
         s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(saved_errno));
-        ub_transport->_handshake.MarkFailed();
+        ub_transport->FailHandshake();
         return NULL;
     }
     HelloMessage remote_msg{};
@@ -356,7 +286,7 @@ void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
                      << s->description();
         s->SetFailed(EPROTO, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(EPROTO));
-        ub_transport->_handshake.MarkFailed();
+        ub_transport->FailHandshake();
         return NULL;
     }
 
@@ -386,24 +316,22 @@ void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
     }
     uint32_t* tmp = (uint32_t*)data;
     *tmp = butil::HostToNet32(flags);
-    if (ub_transport->_handshake.WriteAll(data, ACK_MSG_LEN) < 0) {
+    if (ub_transport->_handshake.io()->WriteAll(data, ACK_MSG_LEN) < 0) {
         const int saved_errno = errno;
         PLOG(WARNING) << "Fail to send Ack Message to server:" << s->description();
         s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(saved_errno));
-        ub_transport->_handshake.MarkFailed();
+        ub_transport->FailHandshake();
         return NULL;
     }
 
     if (ub_transport->_ub_state == UBShmTransport::UB_ON) {
-        ub_transport->_handshake.MarkEstablished();
+        ub_transport->ActivateHighSpeed();
         ep->_ub_ring->UbrUnlinkLocalShm();
         LOG_IF(INFO, FLAGS_ub_trace_verbose) 
             << "Client handshake ends (use ubring) on " << s->description();
     } else {
-        ub_transport->_handshake.PublishFallback([ub_transport]() {
-            ub_transport->_ub_state = UBShmTransport::UB_OFF;
-        });
+        ub_transport->FallbackToTcp();
         LOG_IF(INFO, FLAGS_ub_trace_verbose) 
             << "Client handshake ends (use tcp) on " << s->description();
     }
@@ -424,12 +352,13 @@ void* UBShmTransport::ProcessHandshakeAtServer(void* arg) {
     uint8_t data[g_ub_hello_msg_len];
 
     ub_transport->_handshake.SetPhase(S_HELLO_WAIT);
-    if (ub_transport->_handshake.ReadExact(data, MAGIC_STR_LEN) < 0) {
+    if (ub_transport->_handshake.io()->ReadExact(
+            data, MAGIC_STR_LEN) < 0) {
         const int saved_errno = errno;
         PLOG(WARNING) << "Fail to read Hello Message from client:" << s->description() << " " << s->_remote_side;
         s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(saved_errno));
-        ub_transport->_handshake.MarkFailed();
+        ub_transport->FailHandshake();
         return NULL;
     }
     if (memcmp(data, MAGIC_STR, MAGIC_STR_LEN) != 0) {
@@ -437,20 +366,18 @@ void* UBShmTransport::ProcessHandshakeAtServer(void* arg) {
             << "client does not use RDMA, fallback to TCP:"
             << s->description();
         s->_read_buf.append(data, MAGIC_STR_LEN);
-        ub_transport->_handshake.PublishFallback([ub_transport]() {
-            ub_transport->_ub_state = UBShmTransport::UB_OFF;
-        });
+        ub_transport->FallbackToTcp();
         ub_transport->TryReadOnTcp();
         return NULL;
     }
 
-    if (ub_transport->_handshake.ReadExact(
+    if (ub_transport->_handshake.io()->ReadExact(
             data, g_ub_hello_msg_len - MAGIC_STR_LEN) < 0) {
         const int saved_errno = errno;
         PLOG(WARNING) << "Fail to read Hello Message from client:" << s->description();
         s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(saved_errno));
-        ub_transport->_handshake.MarkFailed();
+        ub_transport->FailHandshake();
         return NULL;
     }
 
@@ -462,7 +389,7 @@ void* UBShmTransport::ProcessHandshakeAtServer(void* arg) {
                      << s->description();
         s->SetFailed(EPROTO, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(EPROTO));
-        ub_transport->_handshake.MarkFailed();
+        ub_transport->FailHandshake();
         return NULL;
     }
     if (remote_msg.msg_len > HELLO_MSG_LEN_MIN) {
@@ -516,22 +443,24 @@ void* UBShmTransport::ProcessHandshakeAtServer(void* arg) {
     }
     memcpy(data, MAGIC_STR, MAGIC_STR_LEN);
     local_msg.Serialize((char*)data + MAGIC_STR_LEN);
-    if (ub_transport->_handshake.WriteAll(data, g_ub_hello_msg_len) < 0) {
+    if (ub_transport->_handshake.io()->WriteAll(
+            data, g_ub_hello_msg_len) < 0) {
         const int saved_errno = errno;
         PLOG(WARNING) << "Fail to send Hello Message to client:" << s->description();
         s->SetFailed(saved_errno, "Fail to complete ub handshake from %s: %s",
                 s->description().c_str(), berror(saved_errno));
-        ub_transport->_handshake.MarkFailed();
+        ub_transport->FailHandshake();
         return NULL;
     }
 
     ub_transport->_handshake.SetPhase(S_ACK_WAIT);
-    if (ub_transport->_handshake.ReadExact(data, ACK_MSG_LEN) < 0) {
+    if (ub_transport->_handshake.io()->ReadExact(
+            data, ACK_MSG_LEN) < 0) {
         const int saved_errno = errno;
         PLOG(WARNING) << "Fail to read ack message from client:" << s->description();
         s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
                 s->description().c_str(), berror(saved_errno));
-        ub_transport->_handshake.MarkFailed();
+        ub_transport->FailHandshake();
         return NULL;
     }
 
@@ -543,19 +472,16 @@ void* UBShmTransport::ProcessHandshakeAtServer(void* arg) {
                          << s->description();
             s->SetFailed(EPROTO, "Fail to complete ub handshake from %s: %s",
                     s->description().c_str(), berror(EPROTO));
-            ub_transport->_handshake.MarkFailed();
+            ub_transport->FailHandshake();
             return NULL;
         } else {
-            ub_transport->_ub_state = UBShmTransport::UB_ON;
-            ub_transport->_handshake.MarkEstablished();
+            ub_transport->ActivateHighSpeed();
             ep->_ub_ring->UbrUnlinkLocalShm();
             LOG_IF(INFO, FLAGS_ub_trace_verbose) 
                 << "Server handshake ends (use ubring) on " << s->description();
         }
     } else {
-        ub_transport->_handshake.PublishFallback([ub_transport]() {
-            ub_transport->_ub_state = UBShmTransport::UB_OFF;
-        });
+        ub_transport->FallbackToTcp();
         LOG_IF(INFO, FLAGS_ub_trace_verbose) 
             << "Server handshake ends (use tcp) on " << s->description();
     }
diff --git a/src/brpc/ubshm_transport.cpp b/src/brpc/ubshm_transport.cpp
index 988db16478..2b36e5508a 100644
--- a/src/brpc/ubshm_transport.cpp
+++ b/src/brpc/ubshm_transport.cpp
@@ -18,7 +18,6 @@
 #if BRPC_WITH_UBRING
 
 #include "brpc/ubshm_transport.h"
-#include "brpc/tcp_transport.h"
 #include "brpc/ubshm/ub_endpoint.h"
 #include "brpc/ubshm/ub_helper.h"
 
@@ -30,7 +29,6 @@ extern SocketVarsCollector *g_vars;
 
 void UBShmTransport::Init(Socket *socket, const SocketOptions &options) {
     CHECK(_ub_ep == NULL);
-    _handshake.Reset(socket);
     if (options.socket_mode == SOCKET_MODE_UBRING) {
         _ub_ep = new(std::nothrow)ubring::UBShmEndpoint(socket);
         if (!_ub_ep) {
@@ -44,14 +42,7 @@ void UBShmTransport::Init(Socket *socket, const SocketOptions &options) {
         _ub_state = UB_OFF;
         socket->_socket_mode = SOCKET_MODE_TCP;
     }
-    _socket = socket;
-    _default_connect = options.app_connect;
-    _on_edge_trigger = options.on_edge_triggered_events;
-    if (options.need_on_edge_trigger && _on_edge_trigger == NULL) {
-        _on_edge_trigger = UBShmTransport::OnNewDataFromTcp;
-    }
-    _tcp_transport = std::make_shared<TcpTransport>();
-    _tcp_transport->Init(socket, options);
+    InitUpgradeTransport(socket, options, UpgradeTransport::OnNewDataFromTcp);
 }
 
 void UBShmTransport::Release() {
@@ -67,7 +58,7 @@ int UBShmTransport::Reset(int32_t expected_nref) {
         _ub_ep->Reset();
         _ub_state = UB_UNKNOWN;
     }
-    _handshake.Reset(_socket);
+    ResetUpgradeTransport();
     return 0;
 }
 
@@ -78,57 +69,42 @@ std::shared_ptr<AppConnect> UBShmTransport::Connect() {
     return _default_connect;
 }
 
-int UBShmTransport::CutFromIOBuf(butil::IOBuf *buf) {
-    if (_ub_ep && _ub_state == UB_ON) {
-        butil::IOBuf *data_arr[1] = {buf};
-        return _ub_ep->CutFromIOBufList(data_arr, 1);
-    } else {
-        return _tcp_transport->CutFromIOBuf(buf);
-    }
+void UBShmTransport::SetHighSpeedAvailable(bool available) {
+    _ub_state = available ? UB_ON : UB_OFF;
 }
 
-ssize_t UBShmTransport::CutFromIOBufList(butil::IOBuf **buf, size_t ndata) {
-    if (_ub_ep && _ub_state == UB_ON) {
-        return _ub_ep->CutFromIOBufList(buf, ndata);
-    }
-    return _tcp_transport->CutFromIOBufList(buf, ndata);
+ssize_t UBShmTransport::CutFromHighSpeedIOBufList(
+    butil::IOBuf** buf, size_t ndata) {
+    CHECK(_ub_ep != NULL);
+    return _ub_ep->CutFromIOBufList(buf, ndata);
 }
 
-int UBShmTransport::WaitEpollOut(butil::atomic<int> *_epollout_butex,
-                                    bool pollin, const timespec duetime) {
-    // LOG(INFO) << "mwj pollin4=" << pollin << " duetime=" << butil::timespec_to_microseconds(duetime);
-    if (_ub_state == UB_ON) {
-        // LOG(INFO) << "mwj pollin1=" << pollin;
-        const int expected_val = _epollout_butex->load(butil::memory_order_acquire);
-        CHECK(_ub_ep != NULL);
-        if (!_ub_ep->IsWritable()) {
-            g_vars->nwaitepollout << 1;
-            _ub_ep->PollerRegisterEpollOut(pollin);
-            auto mwj_ret = bthread::butex_wait(_epollout_butex, expected_val, &duetime);
-            // LOG(INFO) << "mwj pollin2=" << pollin << " mwj_ret=" << mwj_ret;
-            if (mwj_ret < 0) {
-                if (errno != EAGAIN && errno != ETIMEDOUT) {
-                    const int saved_errno = errno;
-                    PLOG(WARNING) << "Fail to wait ub window of " << _socket;
-                    _socket->SetFailed(saved_errno,
-                                       "Fail to wait ub window of %s: %s",
-                                       _socket->description().c_str(),
-                                       berror(saved_errno));
-                }
-                if (_socket->Failed()) {
-                    // NOTE:
-                    // Different from TCP, we cannot find the UB channel
-                    // failed by writing to it. Thus we must check if it
-                    // is already failed here.
-                    return 1;
-                }
+int UBShmTransport::WaitHighSpeedEpollOut(
+    butil::atomic<int>* epollout_butex, bool pollin, timespec duetime) {
+    const int expected_val = epollout_butex->load(butil::memory_order_acquire);
+    CHECK(_ub_ep != NULL);
+    if (!_ub_ep->IsWritable()) {
+        g_vars->nwaitepollout << 1;
+        _ub_ep->PollerRegisterEpollOut(pollin);
+        const int rc = bthread::butex_wait(
+            epollout_butex, expected_val, &duetime);
+        if (rc < 0) {
+            if (errno != EAGAIN && errno != ETIMEDOUT) {
+                const int saved_errno = errno;
+                PLOG(WARNING) << "Fail to wait ub window of " << _socket;
+                _socket->SetFailed(saved_errno,
+                                   "Fail to wait ub window of %s: %s",
+                                   _socket->description().c_str(),
+                                   berror(saved_errno));
+            }
+            if (_socket->Failed()) {
+                // Unlike TCP, writing cannot discover an already failed UB
+                // channel, so check the Socket failure here.
+                return 1;
             }
-            _ub_ep->PollerUnRegisterEpollOut(pollin);
         }
-    } else {
-        return _tcp_transport->WaitEpollOut(_epollout_butex, pollin, duetime);
+        _ub_ep->PollerUnRegisterEpollOut(pollin);
     }
-    // LOG(INFO) << "mwj return 0";
     return 0;
 }
 
diff --git a/src/brpc/ubshm_transport.h b/src/brpc/ubshm_transport.h
index 4457a1cfa9..ed79fb0815 100644
--- a/src/brpc/ubshm_transport.h
+++ b/src/brpc/ubshm_transport.h
@@ -20,14 +20,13 @@
 #if BRPC_WITH_UBRING
 #include "brpc/socket.h"
 #include "brpc/channel.h"
-#include "brpc/transport.h"
-#include "brpc/transport_handshake.h"
+#include "brpc/upgrade_transport.h"
 
 namespace brpc {
-class UBShmTransport : public Transport {
+class UBShmTransport : public UpgradeTransport {
     friend class TransportFactory;
     friend class ubring::UBShmEndpoint;
-friend class ubring::UBConnect;
+    friend class ubring::UBConnect;
 public:
     enum HandshakeState {
         UNINIT = 0x0,
@@ -49,9 +48,6 @@ friend class ubring::UBConnect;
     void Release() override;
     int Reset(int32_t expected_nref) override;
     std::shared_ptr<AppConnect> Connect() override;
-    int CutFromIOBuf(butil::IOBuf* buf) override;
-    ssize_t CutFromIOBufList(butil::IOBuf** buf, size_t ndata) override;
-    int WaitEpollOut(butil::atomic<int>* _epollout_butex, bool pollin, const timespec duetime) override;
     void ProcessEvent(bthread_attr_t attr) override;
     void QueueMessage(InputMessageClosure& inputMsg, int* num_bthread_created, bool last_msg) override;
     void Debug(std::ostream &os) override;
@@ -60,10 +56,16 @@ friend class ubring::UBConnect;
         return _ub_ep;
     }
     static int ContextInitOrDie(bool serverOrNot, const void* _options);
-    static void OnNewDataFromTcp(Socket* socket);
     static void* ProcessHandshakeAtClient(void* arg);
     static void* ProcessHandshakeAtServer(void* arg);
 private:
+    void SetHighSpeedAvailable(bool available) override;
+    ssize_t CutFromHighSpeedIOBufList(
+        butil::IOBuf** buf, size_t ndata) override;
+    int WaitHighSpeedEpollOut(butil::atomic<int>* epollout_butex,
+                              bool pollin, timespec duetime) override;
+    void StartServerHandshake() override;
+
     static bool OptionsAvailableForUB(const ChannelOptions* opt);
     static bool OptionsAvailableOverUB(const ServerOptions* opt);
 private:
@@ -77,10 +79,6 @@ friend class ubring::UBConnect;
     ubring::UBShmEndpoint* _ub_ep = NULL;
     // Should use UB or not
     UBState _ub_state;
-    std::shared_ptr<TcpTransport>  _tcp_transport;
-    handshake::SocketHandshakeIO _handshake;
-
-    void TryReadOnTcp();
 };
 } // namespace brpc
 #endif // BRPC_WITH_UBRING
diff --git a/src/brpc/upgrade_transport.cpp b/src/brpc/upgrade_transport.cpp
new file mode 100644
index 0000000000..a5c6e87575
--- /dev/null
+++ b/src/brpc/upgrade_transport.cpp
@@ -0,0 +1,155 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "brpc/upgrade_transport.h"
+
+#include <cstdint>
+#include <errno.h>
+#include <unistd.h>
+
+#include "brpc/input_messenger.h"
+#include "brpc/tcp_transport.h"
+
+namespace brpc {
+
+void UpgradeTransport::InitUpgradeTransport(
+    Socket* socket, const SocketOptions& options,
+    const OnEdgeTrigger& default_on_edge) {
+    _socket = socket;
+    _default_connect = options.app_connect;
+    _on_edge_trigger = options.on_edge_triggered_events;
+    if (options.need_on_edge_trigger && _on_edge_trigger == NULL) {
+        _on_edge_trigger = default_on_edge;
+    }
+    _handshake.Reset(socket);
+    _tcp_transport = std::make_shared<TcpTransport>();
+    _tcp_transport->Init(socket, options);
+}
+
+void UpgradeTransport::ResetUpgradeTransport() {
+    _handshake.Reset(_socket);
+}
+
+int UpgradeTransport::CutFromIOBuf(butil::IOBuf* buf) {
+    if (_handshake.phase() == handshake::ESTABLISHED) {
+        butil::IOBuf* data[1] = {buf};
+        return CutFromHighSpeedIOBufList(data, 1);
+    }
+    return _tcp_transport->CutFromIOBuf(buf);
+}
+
+ssize_t UpgradeTransport::CutFromIOBufList(
+    butil::IOBuf** buf, size_t ndata) {
+    if (_handshake.phase() == handshake::ESTABLISHED) {
+        return CutFromHighSpeedIOBufList(buf, ndata);
+    }
+    return _tcp_transport->CutFromIOBufList(buf, ndata);
+}
+
+int UpgradeTransport::WaitEpollOut(butil::atomic<int>* epollout_butex,
+                                    bool pollin, timespec duetime) {
+    if (_handshake.phase() == handshake::ESTABLISHED) {
+        return WaitHighSpeedEpollOut(epollout_butex, pollin, duetime);
+    }
+    return _tcp_transport->WaitEpollOut(epollout_butex, pollin, duetime);
+}
+
+void UpgradeTransport::ActivateHighSpeed() {
+    SetHighSpeedAvailable(true);
+    _handshake.MarkEstablished();
+}
+
+void UpgradeTransport::FallbackToTcp() {
+    _handshake.PublishFallback([this]() {
+        SetHighSpeedAvailable(false);
+    });
+}
+
+void UpgradeTransport::FailHandshake() {
+    _handshake.MarkFailed();
+}
+
+void UpgradeTransport::OnNewDataFromTcp(Socket* socket) {
+    static_cast<UpgradeTransport*>(socket->_transport.get())->ProcessTcpEvent();
+}
+
+void UpgradeTransport::ProcessTcpEvent() {
+    int progress = Socket::PROGRESS_INIT;
+    while (true) {
+        const int phase = _handshake.phase();
+        if (phase == handshake::UNINITIALIZED) {
+            if (!_socket->CreatedByConnect()) {
+                StartServerHandshake();
+                if (_handshake.phase() != handshake::UNINITIALIZED) {
+                    continue;
+                }
+            }
+        } else if (phase < handshake::ESTABLISHED) {
+            _handshake.NotifyReadable();
+        } else if (phase == handshake::FALLBACK_TCP) {
+            InputMessenger::OnNewMessages(_socket);
+            return;
+        } else if (phase == handshake::ESTABLISHED) {
+            CheckUnexpectedTcpData();
+            return;
+        }
+        if (!_socket->MoreReadEvents(&progress)) {
+            break;
+        }
+    }
+}
+
+void UpgradeTransport::CheckUnexpectedTcpData() {
+    int progress = Socket::PROGRESS_INIT;
+    while (true) {
+        uint8_t byte;
+        const ssize_t nr = read(_socket->fd(), &byte, 1);
+        if (nr == 0) {
+            _socket->SetEOF();
+            return;
+        }
+        if (nr > 0) {
+            _socket->SetFailed(EPROTO, "Read unexpected data from %s",
+                               _socket->description().c_str());
+            return;
+        }
+        if (errno != EAGAIN) {
+            const int saved_errno = errno;
+            _socket->SetFailed(saved_errno, "Fail to read from %s: %s",
+                               _socket->description().c_str(),
+                               berror(saved_errno));
+            return;
+        }
+        if (!_socket->MoreReadEvents(&progress)) {
+            return;
+        }
+    }
+}
+
+void UpgradeTransport::TryReadOnTcp() {
+    if (_socket->_nevent.fetch_add(1, butil::memory_order_acq_rel) != 0) {
+        return;
+    }
+    const int phase = _handshake.phase();
+    if (phase == handshake::FALLBACK_TCP) {
+        InputMessenger::OnNewMessages(_socket);
+    } else if (phase == handshake::ESTABLISHED) {
+        CheckUnexpectedTcpData();
+    }
+}
+
+}  // namespace brpc
diff --git a/src/brpc/upgrade_transport.h b/src/brpc/upgrade_transport.h
new file mode 100644
index 0000000000..5cd5d8237e
--- /dev/null
+++ b/src/brpc/upgrade_transport.h
@@ -0,0 +1,78 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#ifndef BRPC_UPGRADE_TRANSPORT_H
+#define BRPC_UPGRADE_TRANSPORT_H
+
+#include <memory>
+
+#include "brpc/transport.h"
+#include "brpc/transport_handshake.h"
+
+namespace brpc {
+
+class TcpTransport;
+
+// A TCP-first transport that may switch its data plane after a successful
+// handshake. TCP remains usable before negotiation and after fallback.
+class UpgradeTransport : public Transport {
+public:
+    int CutFromIOBuf(butil::IOBuf* buf) override;
+    ssize_t CutFromIOBufList(butil::IOBuf** buf, size_t ndata) override;
+    int WaitEpollOut(butil::atomic<int>* epollout_butex,
+                     bool pollin, timespec duetime) override;
+
+    int handshake_phase() const { return _handshake.phase(); }
+    int handshake_version() const { return _handshake.protocol_version(); }
+
+    static void OnNewDataFromTcp(Socket* socket);
+
+protected:
+    UpgradeTransport() = default;
+    ~UpgradeTransport() override = default;
+
+    void InitUpgradeTransport(Socket* socket, const SocketOptions& options,
+                              const OnEdgeTrigger& default_on_edge);
+    void ResetUpgradeTransport();
+
+    void ActivateHighSpeed();
+    void FallbackToTcp();
+    void FailHandshake();
+    void TryReadOnTcp();
+
+    virtual void SetHighSpeedAvailable(bool available) = 0;
+    virtual ssize_t CutFromHighSpeedIOBufList(
+        butil::IOBuf** buf, size_t ndata) = 0;
+    virtual int WaitHighSpeedEpollOut(butil::atomic<int>* epollout_butex,
+                                      bool pollin, timespec duetime) = 0;
+
+    // Called only for an accepted socket whose handshake phase is still
+    // UNINITIALIZED. Protocols parsed by InputMessenger can leave this as a
+    // no-op and install InputMessenger::OnNewMessages on server sockets.
+    virtual void StartServerHandshake() {}
+
+    handshake::HandshakeSession _handshake;
+    std::shared_ptr<TcpTransport> _tcp_transport;
+
+private:
+    void ProcessTcpEvent();
+    void CheckUnexpectedTcpData();
+};
+
+}  // namespace brpc
+
+#endif  // BRPC_UPGRADE_TRANSPORT_H
diff --git a/test/brpc_transport_handshake_unittest.cpp b/test/brpc_transport_handshake_unittest.cpp
index 126deb915e..7a47860fc4 100644
--- a/test/brpc_transport_handshake_unittest.cpp
+++ b/test/brpc_transport_handshake_unittest.cpp
@@ -23,7 +23,7 @@ namespace brpc {
 namespace handshake {
 
 TEST(TransportHandshakeTest, publish_fallback_after_tcp_state) {
-    SocketHandshakeIO handshake;
+    HandshakeSession handshake;
     int tcp_active = 0;
 
     handshake.SetPhase(NEGOTIATING);
@@ -34,12 +34,15 @@ TEST(TransportHandshakeTest, publish_fallback_after_tcp_state) {
 }
 
 TEST(TransportHandshakeTest, reset_clears_terminal_state) {
-    SocketHandshakeIO handshake;
+    HandshakeSession handshake;
+    handshake.set_protocol_version(3);
     handshake.MarkEstablished();
     ASSERT_EQ(ESTABLISHED, handshake.phase());
+    ASSERT_EQ(3, handshake.protocol_version());
 
     handshake.Reset(NULL);
     ASSERT_EQ(UNINITIALIZED, handshake.phase());
+    ASSERT_EQ(0, handshake.protocol_version());
 }
 
 }  // namespace handshake

From da30d0d0e7b7407297d542e8b33f9988ffdff360 Mon Sep 17 00:00:00 2001
From: Gzure <740684863@qq.com>
Date: Mon, 17 Aug 2026 16:20:20 +0800
Subject: [PATCH 04/11] Move handshake processing into common session

---
 docs/cn/handshake_common_design.md         |  49 ++-
 src/brpc/rdma_transport.cpp                | 256 ++++++------
 src/brpc/transport_handshake.cpp           | 145 +++++++
 src/brpc/transport_handshake.h             |  51 +++
 src/brpc/ubshm/ub_endpoint.cpp             | 429 +++++++++++----------
 src/brpc/upgrade_transport.cpp             |   9 -
 src/brpc/upgrade_transport.h               |   2 -
 test/brpc_transport_handshake_unittest.cpp | 175 +++++++++
 8 files changed, 751 insertions(+), 365 deletions(-)

diff --git a/docs/cn/handshake_common_design.md b/docs/cn/handshake_common_design.md
index 840c876ac4..743035f007 100644
--- a/docs/cn/handshake_common_design.md
+++ b/docs/cn/handshake_common_design.md
@@ -130,7 +130,7 @@ src/brpc/
 flowchart TB
     S["Socket"] --> UT["UpgradeTransport\nTCP-first 路由与状态发布"]
     UT --> TCP["TcpTransport\n默认数据面 / fallback"]
-    UT --> HS["HandshakeSession\nphase / version / lifecycle"]
+    UT --> HS["HandshakeSession\nclient/server driver + lifecycle"]
     HS --> IO["SocketHandshakeIO\nReadExact / WriteAll / readable butex"]
     UT --> RA["RDMA adapter"]
     UT --> UA["URMA adapter"]
@@ -140,7 +140,7 @@ flowchart TB
     BA --> BE["UBShmEndpoint\nUBRing / Shared Memory"]
 ```
 
-`UpgradeTransport` 决定当前数据走 TCP 还是高速 Endpoint；`HandshakeSession` 只管理一次升级尝试；具体 adapter 负责 Hello/ACK wire codec 和资源协商。Endpoint 不持有 TCP Transport，也不执行 TCP fd 读写。
+`UpgradeTransport` 决定当前数据走 TCP 还是高速 Endpoint；`HandshakeSession` 驱动一次升级尝试的公共步骤；具体 adapter 通过回调完成 Hello/ACK wire codec 和资源协商。Endpoint 不持有 TCP Transport，也不执行 TCP fd 读写。
 
 ## 4.1 选定架构：Handshake 位于 Transport 层
 
@@ -389,7 +389,7 @@ public:
 };
 ```
 
-实际实现中不建议使用裸 `shared_ptr<void>`，更适合使用各协议自己的 `ParsedHello` 结构配合回调，或者让 `HandshakeDriver` 只传递 `std::string payload`，由 endpoint 在回调中解析。
+实际实现中不建议使用裸 `shared_ptr<void>`，更适合使用各协议自己的 `ParsedHello` 结构配合回调，或者让 `HandshakeSession` 只传递步骤结果，由协议 callback 保存强类型上下文。
 
 建议第一版采用回调方式，避免公共头文件包含协议专有类型：
 
@@ -403,7 +403,7 @@ struct HandshakeCallbacks {
 };
 ```
 
-## 6. HandshakeDriver 状态机
+## 6. HandshakeSession 状态机
 
 ### 6.1 Client 流程
 
@@ -448,7 +448,7 @@ server 解析必须保留 `NEED_MORE_DATA`：
 
 ### 6.3 公共驱动不负责的动作
 
-`HandshakeDriver` 在协议成功后只调用回调，不直接操作资源：
+`HandshakeSession` 通过 callback 驱动协议步骤，不直接依赖具体资源类型：
 
 - RDMA：回调中执行 `AllocateResources/BringUpQp`；
 - URMA：回调中执行 `AllocateResources/ImportPeer`；
@@ -525,17 +525,17 @@ UBSHM 是最适合优先迁移的实现，因为它只有固定长度 v2 协议
 
 ```cpp
 class RdmaEndpoint {
-    handshake::HandshakeDriver _handshake;
+    handshake::HandshakeSession _handshake;
     RdmaHandshakeAdapter _handshake_adapter;
 };
 
 class UrmaEndpoint {
-    handshake::HandshakeDriver _handshake;
+    handshake::HandshakeSession _handshake;
     UrmaHandshakeAdapter _handshake_adapter;
 };
 
 class UBShmEndpoint {
-    handshake::HandshakeDriver _handshake;
+    handshake::HandshakeSession _handshake;
     UBShmHandshakeAdapter _handshake_adapter;
 };
 ```
@@ -657,7 +657,7 @@ Hello valid
 ### Phase 2：抽取公共 driver
 
 - 引入统一 `Result/Phase`；
-- 将 client/server 的握手阶段迁移到 `HandshakeDriver`；
+- 将 client/server 的握手阶段迁移到 `HandshakeSession`；
 - 保留各 endpoint 的资源协商回调；
 - 统一 fallback 和错误处理。
 
@@ -715,13 +715,14 @@ classDiagram
         +CutFromIOBuf()
         +CutFromIOBufList()
         +WaitEpollOut()
-        +ActivateHighSpeed()
         +FallbackToTcp()
     }
     class HandshakeSession {
         -SocketHandshakeIO io
         -atomic phase
         -int protocol_version
+        +RunClient(callbacks)
+        +RunServer(callbacks)
         +MarkEstablished()
         +PublishFallback()
         +MarkFailed()
@@ -743,16 +744,16 @@ classDiagram
 
 `UpgradeTransport` 是 TCP-first 的公共路由层：`UNINITIALIZED/NEGOTIATING/FALLBACK_TCP` 都走 `TcpTransport`，仅当 `HandshakeSession` release 发布 `ESTABLISHED` 后才调用高速 Endpoint 的发送与等待钩子。成功升级后的 TCP 控制连接只允许 EOF，不再接受应用数据。
 
-`HandshakeSession` 管理一次升级尝试的 phase、协议版本、fallback/established 发布顺序和 `SocketHandshakeIO`。RDMA/UBSHM 仍保留各自不同的 wire codec、协议中间阶段和资源协商，这是有意保留的 adapter 边界，不再由 Endpoint 持有。
+`HandshakeSession::RunClient/RunServer` 统一执行资源准备、Hello 收发、远端参数协商、ACK 收发以及 established/fallback/failed 发布。RDMA/UBSHM 仅通过 callback 提供 wire codec 和资源操作；RDMA server 的 `STEP_NEED_MORE` 仍由 bRPC 标准 parser 增量驱动，UBSHM server 使用同一驱动的 blocking 模式。
 
 ### 14.1 当前完成度
 
 | 项目 | 状态 | 说明 |
 |---|---|---|
 | TCP-first 路由 | 已实现 | RDMA/UBSHM 共同继承 `UpgradeTransport`，不再各自持有 `TcpTransport` |
-| 公共握手生命周期 | 已实现 | `HandshakeSession` 统一 phase、version、I/O 和终态发布 |
+| 公共握手处理 | 已实现 | `RunClient/RunServer` 统一 Hello、资源协商、ACK、fallback 和错误流程 |
 | RDMA client/server | 已迁移 | server 保留 #3350 的 bRPC 标准协议增量解析流程 |
-| UBSHM client/server | 部分迁移 | 生命周期已进入 Transport；server 固定帧仍由握手 bthread 读取，后续迁移到标准 parser |
+| UBSHM client/server | 已迁移公共驱动 | server 当前使用 blocking 模式；后续只需把输入方式迁移到标准 parser |
 | URMA | 待迁移 | origin/master 暂无受版本控制的 URMA Transport；合入后实现 `UpgradeTransport` 的数据面钩子并复用 `HandshakeSession` |
 | 通用 FrameCodec/Protocol adapter | 待实现 | 当前先复用 RDMA 已验证的 v2/v3 codec，避免一次改动 wire format 与 Transport 生命周期 |
 
@@ -761,26 +762,24 @@ classDiagram
 | 修复 | 公共约束 | 落点 |
 |---|---|---|
 | #3347 | fallback 状态必须原子发布，事件线程用 acquire 读取 | `HandshakeSession::PublishFallback/phase` |
-| #3406 | 必须先发布 Transport 的 TCP active/off 状态，再 release 发布 `FALLBACK_TCP` | `UpgradeTransport::FallbackToTcp` 调整 provider 状态后发布终态 |
+| #3406 | 必须先发布 Transport 的 TCP active/off 状态，再 release 发布 `FALLBACK_TCP` | `HandshakeSession` 先调用 `set_tcp_active` callback，再 release 发布终态 |
 | #3424 | 高速资源准备失败是可降级错误；清理部分资源并保持 TCP 可用 | RDMA 保留事务式 `AllocateResources`；失败后由公共 fallback 路径恢复 TCP |
 | #3425 | CQ re-arm 后同时补 poll send/recv CQ | 保留在 RDMA Endpoint 数据面，不移入握手组件 |
 | #3427 | 外部 Bazel workspace 下生成规则不能依赖主仓布局 | 公共实现不新增 proto；源码通过现有递归 glob 收录 |
 
 ### 14.3 状态发布规则
 
-成功升级和回退只能由 `UpgradeTransport` 发布：
+成功升级和回退由 `HandshakeSession` 按固定顺序发布，Transport callback 只切换 provider 状态：
 
 ```cpp
-void UpgradeTransport::FallbackToTcp() {
-    handshake.PublishFallback([this]() {
-        SetHighSpeedAvailable(false);
-    });
-}
-
-void UpgradeTransport::ActivateHighSpeed() {
-    SetHighSpeedAvailable(true);
-    handshake.MarkEstablished();
-}
+// Fallback: publish TCP/provider state first, then terminal phase.
+PublishFallback([&callbacks]() {
+    callbacks.set_tcp_active();
+});
+
+// Success: endpoint is ready before ESTABLISHED becomes visible.
+callbacks.set_high_speed_active();
+MarkEstablished();
 ```
 
 事件线程必须通过 acquire load 读取 phase。看到 `FALLBACK_TCP` 后可以直接恢复 `InputMessenger`；看到 `ESTABLISHED` 后才允许发送和接收高速数据。`UNINITIALIZED/NEGOTIATING` 状态不得路由到 Endpoint 数据面。
diff --git a/src/brpc/rdma_transport.cpp b/src/brpc/rdma_transport.cpp
index 562ef29ce5..1af007a8b0 100644
--- a/src/brpc/rdma_transport.cpp
+++ b/src/brpc/rdma_transport.cpp
@@ -85,81 +85,90 @@ void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
     LOG_IF(INFO, rdma::FLAGS_rdma_trace_verbose)
         << "Start handshake on " << socket->description();
 
-    std::unique_ptr<rdma::RdmaHandshake> handshake =
+    std::unique_ptr<rdma::RdmaHandshake> protocol =
         rdma::CreateClientHandshake(ep, transport->_handshake.io());
-    CHECK(handshake != NULL);
-    transport->_handshake.set_protocol_version(handshake->ProtocolVersion());
+    CHECK(protocol != NULL);
+    transport->_handshake.set_protocol_version(protocol->ProtocolVersion());
+    rdma::ParsedHello remote{};
 
-    transport->_handshake.SetPhase(C_ALLOC_QPCQ);
-    if (ep->AllocateResources() < 0) {
+    handshake::ClientHandshakeCallbacks callbacks{};
+    callbacks.phases = handshake::HandshakePhases{
+        C_ALLOC_QPCQ, C_HELLO_SEND, C_HELLO_WAIT,
+        C_BRINGUP_QP, C_ACK_SEND, 0};
+    callbacks.prepare_local = [&]() {
+        if (ep->AllocateResources() == 0) {
+            return handshake::STEP_OK;
+        }
         PLOG(WARNING) << "Fail to allocate rdma resources, fallback to tcp:"
                       << socket->description();
         // Resource preparation is transactional (see #3424): partial RDMA
         // resources are cleaned by AllocateResources and TCP remains usable.
         errno = 0;
-        transport->FallbackToTcp();
-        return NULL;
-    }
-
-    transport->_handshake.SetPhase(C_HELLO_SEND);
-    if (handshake->SendLocalHello() < 0) {
+        return handshake::STEP_FALLBACK;
+    };
+    callbacks.send_local_hello = [&]() {
+        if (protocol->SendLocalHello() == 0) {
+            return handshake::STEP_OK;
+        }
         const int saved_errno = errno;
         socket->SetFailed(saved_errno,
                           "Fail to complete rdma handshake from %s: %s",
                           socket->description().c_str(), berror(saved_errno));
-        transport->FailHandshake();
-        return NULL;
-    }
-
-    transport->_handshake.SetPhase(C_HELLO_WAIT);
-    rdma::ParsedHello remote{};
-    const rdma::RemoteHelloResult result =
-        handshake->ReceiveAndParseRemoteHello(&remote);
-    if (result == rdma::RemoteHelloResult::ERROR) {
+        return handshake::STEP_ERROR;
+    };
+    callbacks.receive_remote_hello = [&]() {
+        const rdma::RemoteHelloResult result =
+            protocol->ReceiveAndParseRemoteHello(&remote);
+        if (result == rdma::RemoteHelloResult::NEGOTIATED) {
+            return handshake::STEP_OK;
+        }
+        if (result != rdma::RemoteHelloResult::ERROR) {
+            return handshake::STEP_FALLBACK;
+        }
         const int saved_errno = errno;
         socket->SetFailed(saved_errno,
                           "Fail to complete rdma handshake from %s: %s",
                           socket->description().c_str(), berror(saved_errno));
-        transport->FailHandshake();
-        return NULL;
-    }
-
-    if (result != rdma::RemoteHelloResult::NEGOTIATED) {
-        transport->_rdma_state = RDMA_OFF;
-    } else {
+        return handshake::STEP_ERROR;
+    };
+    callbacks.negotiate_resources = [&]() {
         ep->ApplyRemoteHello(remote);
-        transport->_handshake.SetPhase(C_BRINGUP_QP);
-        if (ep->BringUpQp(remote, false) < 0) {
-            LOG(WARNING) << "Fail to bringup QP, fallback to tcp:"
-                         << socket->description();
-            transport->_rdma_state = RDMA_OFF;
-        } else {
-            transport->_rdma_state = RDMA_ON;
+        if (ep->BringUpQp(remote, false) == 0) {
+            return handshake::STEP_OK;
+        }
+        LOG(WARNING) << "Fail to bringup QP, fallback to tcp:"
+                     << socket->description();
+        return handshake::STEP_FALLBACK;
+    };
+    callbacks.send_ack = [&](bool enabled) {
+        const uint32_t flags_be = butil::HostToNet32(
+            enabled ? rdma::HELLO_ACK_RDMA_OK : 0);
+        if (transport->_handshake.io()->WriteAll(
+                &flags_be, rdma::HELLO_ACK_LEN) == 0) {
+            return handshake::STEP_OK;
         }
-    }
-
-    transport->_handshake.SetPhase(C_ACK_SEND);
-    const bool rdma_on = transport->_rdma_state == RDMA_ON;
-    const uint32_t flags_be = butil::HostToNet32(
-        rdma_on ? rdma::HELLO_ACK_RDMA_OK : 0);
-    if (transport->_handshake.io()->WriteAll(
-            &flags_be, rdma::HELLO_ACK_LEN) < 0) {
         const int saved_errno = errno;
         socket->SetFailed(saved_errno,
                           "Fail to complete rdma handshake from %s: %s",
                           socket->description().c_str(), berror(saved_errno));
-        transport->FailHandshake();
-        return NULL;
-    }
-
-    if (rdma_on) {
-        transport->ActivateHighSpeed();
+        return handshake::STEP_ERROR;
+    };
+    callbacks.set_high_speed_active = [transport]() {
+        transport->SetHighSpeedAvailable(true);
+    };
+    callbacks.set_tcp_active = [transport]() {
+        transport->SetHighSpeedAvailable(false);
+    };
+    callbacks.on_failed = []() {};
+
+    const handshake::StepResult result =
+        transport->_handshake.RunClient(callbacks);
+    if (result == handshake::STEP_OK) {
         LOG_IF(INFO, rdma::FLAGS_rdma_trace_verbose)
             << "Client handshake ends (use rdma v"
             << transport->handshake_version() << ") on "
             << socket->description();
-    } else {
-        transport->FallbackToTcp();
+    } else if (result == handshake::STEP_FALLBACK) {
         LOG_IF(INFO, rdma::FLAGS_rdma_trace_verbose)
             << "Client handshake ends (use tcp) on " << socket->description();
     }
@@ -174,93 +183,102 @@ ParseResult RdmaTransport::ExecuteServerHandshake(butil::IOBuf* source,
     rdma::RdmaEndpoint* ep = transport->_rdma_ep;
     CHECK(ep != NULL);
 
-    if (socket->parsing_context() == NULL) {
+    std::unique_ptr<rdma::RdmaHandshake> protocol;
+    rdma::ParsedHello remote{};
+    handshake::ServerHandshakeCallbacks callbacks{};
+    callbacks.phases = handshake::HandshakePhases{
+        S_ALLOC_QPCQ, S_HELLO_SEND, S_HELLO_WAIT,
+        S_BRINGUP_QP, 0, S_ACK_WAIT};
+    callbacks.blocking = false;
+    callbacks.fallback_on_not_mine = false;
+    callbacks.receive_remote_hello = [&]() {
         if (source->size() < rdma::HELLO_MAGIC_LEN) {
-            return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
+            return handshake::STEP_NEED_MORE;
         }
         uint8_t magic[rdma::HELLO_MAGIC_LEN];
         CHECK_EQ(source->copy_to(magic, sizeof(magic)), sizeof(magic));
-        std::unique_ptr<rdma::RdmaHandshake> handshake =
-            rdma::CreateServerHandshakeByMagic(
-                ep, transport->_handshake.io(), source, magic);
-        if (handshake == NULL) {
-            return MakeParseError(PARSE_ERROR_TRY_OTHERS);
+        protocol = rdma::CreateServerHandshakeByMagic(
+            ep, transport->_handshake.io(), source, magic);
+        if (protocol == NULL) {
+            return handshake::STEP_NOT_MINE;
         }
-        transport->_handshake.set_protocol_version(handshake->ProtocolVersion());
-        transport->_handshake.SetPhase(S_HELLO_WAIT);
-
-        rdma::ParsedHello remote{};
+        transport->_handshake.set_protocol_version(protocol->ProtocolVersion());
         const rdma::RemoteHelloResult result =
-            handshake->ReceiveAndParseRemoteHello(&remote);
+            protocol->ReceiveAndParseRemoteHello(&remote);
         if (result == rdma::RemoteHelloResult::NEED_MORE) {
-            return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
+            return handshake::STEP_NEED_MORE;
         }
         if (result == rdma::RemoteHelloResult::ERROR) {
-            transport->FailHandshake();
-            return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
+            return handshake::STEP_ERROR;
         }
-
-        bool negotiated = result == rdma::RemoteHelloResult::NEGOTIATED;
-        if (negotiated) {
-            ep->ApplyRemoteHello(remote);
-            transport->_handshake.SetPhase(S_ALLOC_QPCQ);
-            if (ep->AllocateResources() < 0) {
-                PLOG(WARNING) << "Fail to allocate rdma resources, fallback to tcp:"
-                              << socket->description();
-                negotiated = false;
-            } else {
-                transport->_handshake.SetPhase(S_BRINGUP_QP);
-                if (ep->BringUpQp(remote, true) < 0) {
-                    negotiated = false;
-                }
-            }
+        if (result == rdma::RemoteHelloResult::NEGOTIATED) {
+            return handshake::STEP_OK;
+        }
+        transport->_rdma_state = RDMA_OFF;
+        return handshake::STEP_FALLBACK;
+    };
+    callbacks.prepare_local = [&]() {
+        ep->ApplyRemoteHello(remote);
+        if (ep->AllocateResources() < 0) {
+            PLOG(WARNING) << "Fail to allocate rdma resources, fallback to tcp:"
+                          << socket->description();
+            transport->_rdma_state = RDMA_OFF;
+            return handshake::STEP_FALLBACK;
         }
-        if (!negotiated) {
+        return handshake::STEP_OK;
+    };
+    callbacks.negotiate_resources = [&]() {
+        if (ep->BringUpQp(remote, true) < 0) {
             transport->_rdma_state = RDMA_OFF;
+            return handshake::STEP_FALLBACK;
         }
-
-        transport->_handshake.SetPhase(S_HELLO_SEND);
-        if (handshake->SendLocalHello() < 0) {
-            transport->FailHandshake();
-            return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
+        return handshake::STEP_OK;
+    };
+    callbacks.send_local_hello = [&](bool) {
+        CHECK(protocol != NULL);
+        return protocol->SendLocalHello() == 0
+            ? handshake::STEP_OK : handshake::STEP_ERROR;
+    };
+    callbacks.receive_ack = [&]() {
+        if (source->size() < rdma::HELLO_ACK_LEN) {
+            return handshake::STEP_NEED_MORE;
+        }
+        uint32_t flags_be = 0;
+        CHECK_EQ(source->cutn(&flags_be, rdma::HELLO_ACK_LEN),
+                 rdma::HELLO_ACK_LEN);
+        const bool client_ack_ok =
+            (butil::NetToHost32(flags_be) & rdma::HELLO_ACK_RDMA_OK) != 0;
+        if (!client_ack_ok) {
+            // Keep coalesced RPC bytes for InputMessenger after fallback.
+            return handshake::STEP_FALLBACK;
+        }
+        if (!source->empty() || transport->_rdma_state == RDMA_OFF) {
+            return handshake::STEP_ERROR;
+        }
+        return handshake::STEP_OK;
+    };
+    callbacks.set_high_speed_active = [transport]() {
+        transport->SetHighSpeedAvailable(true);
+    };
+    callbacks.set_tcp_active = [transport]() {
+        transport->SetHighSpeedAvailable(false);
+    };
+    callbacks.on_failed = []() {};
+
+    const handshake::StepResult result =
+        transport->_handshake.RunServer(callbacks);
+    if (result == handshake::STEP_NEED_MORE) {
+        if (transport->_handshake.phase() == S_ACK_WAIT &&
+            socket->parsing_context() == NULL) {
+            socket->reset_parsing_context(
+                rdma::ServerHandshakeContext::Create());
         }
-        socket->reset_parsing_context(rdma::ServerHandshakeContext::Create());
-        transport->_handshake.SetPhase(S_ACK_WAIT);
-        return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
-    }
-
-    if (source->size() < rdma::HELLO_ACK_LEN) {
         return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
     }
-    uint32_t flags_be = 0;
-    CHECK_EQ(source->cutn(&flags_be, rdma::HELLO_ACK_LEN),
-             rdma::HELLO_ACK_LEN);
-    const bool client_ack_ok =
-        (butil::NetToHost32(flags_be) & rdma::HELLO_ACK_RDMA_OK) != 0;
-    if (!client_ack_ok) {
-        // Keep any coalesced RPC bytes in source. After the release-published
-        // fallback, InputMessenger will continue parsing them as TCP data.
-        transport->FallbackToTcp();
-        socket->reset_parsing_context(NULL);
-        return MakeParseError(PARSE_ERROR_TRY_OTHERS);
-    }
-
-    if (!source->empty()) {
-        // A successful RDMA upgrade must not carry application bytes on the
-        // TCP control connection after the ACK.
-        transport->FailHandshake();
-        socket->reset_parsing_context(NULL);
-        return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
-    }
-
-    if (transport->_rdma_state == RDMA_OFF) {
-        transport->FailHandshake();
-        socket->reset_parsing_context(NULL);
+    socket->reset_parsing_context(NULL);
+    if (result == handshake::STEP_ERROR) {
         return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
     }
-
-    transport->ActivateHighSpeed();
-    socket->reset_parsing_context(NULL);
     return MakeParseError(PARSE_ERROR_TRY_OTHERS);
 }
 
diff --git a/src/brpc/transport_handshake.cpp b/src/brpc/transport_handshake.cpp
index 56ef518ff9..3258e749df 100644
--- a/src/brpc/transport_handshake.cpp
+++ b/src/brpc/transport_handshake.cpp
@@ -150,5 +150,150 @@ int SocketHandshakeIO::WriteAll(butil::IOBuf* data) {
         });
 }
 
+static StepResult FinishWithFailure(
+    HandshakeSession* session, const std::function<void()>& on_failed) {
+    if (on_failed) {
+        on_failed();
+    }
+    session->MarkFailed();
+    return STEP_ERROR;
+}
+
+static StepResult FinishWithFallback(
+    HandshakeSession* session, const std::function<void()>& set_tcp_active) {
+    session->PublishFallback([&set_tcp_active]() {
+        if (set_tcp_active) {
+            set_tcp_active();
+        }
+    });
+    return STEP_FALLBACK;
+}
+
+StepResult HandshakeSession::RunClient(
+    const ClientHandshakeCallbacks& callbacks) {
+    CHECK(callbacks.prepare_local);
+    CHECK(callbacks.send_local_hello);
+    CHECK(callbacks.receive_remote_hello);
+    CHECK(callbacks.negotiate_resources);
+    CHECK(callbacks.send_ack);
+    CHECK(callbacks.set_high_speed_active);
+    CHECK(callbacks.set_tcp_active);
+
+    SetPhase(callbacks.phases.prepare_local);
+    StepResult result = callbacks.prepare_local();
+    if (result == STEP_FALLBACK) {
+        return FinishWithFallback(this, callbacks.set_tcp_active);
+    }
+    if (result != STEP_OK) {
+        return FinishWithFailure(this, callbacks.on_failed);
+    }
+
+    SetPhase(callbacks.phases.hello_send);
+    if (callbacks.send_local_hello() != STEP_OK) {
+        return FinishWithFailure(this, callbacks.on_failed);
+    }
+
+    SetPhase(callbacks.phases.hello_wait);
+    result = callbacks.receive_remote_hello();
+    if (result == STEP_ERROR || result == STEP_NOT_MINE ||
+        result == STEP_NEED_MORE) {
+        return FinishWithFailure(this, callbacks.on_failed);
+    }
+    bool enabled = result == STEP_OK;
+
+    if (enabled) {
+        SetPhase(callbacks.phases.negotiate);
+        result = callbacks.negotiate_resources();
+        if (result != STEP_OK && result != STEP_FALLBACK) {
+            return FinishWithFailure(this, callbacks.on_failed);
+        }
+        enabled = result == STEP_OK;
+    }
+
+    SetPhase(callbacks.phases.ack_send);
+    if (callbacks.send_ack(enabled) != STEP_OK) {
+        return FinishWithFailure(this, callbacks.on_failed);
+    }
+
+    if (enabled) {
+        callbacks.set_high_speed_active();
+        MarkEstablished();
+        return STEP_OK;
+    }
+    return FinishWithFallback(this, callbacks.set_tcp_active);
+}
+
+StepResult HandshakeSession::RunServer(
+    const ServerHandshakeCallbacks& callbacks) {
+    CHECK(callbacks.receive_remote_hello);
+    CHECK(callbacks.prepare_local);
+    CHECK(callbacks.negotiate_resources);
+    CHECK(callbacks.send_local_hello);
+    CHECK(callbacks.receive_ack);
+    CHECK(callbacks.set_high_speed_active);
+    CHECK(callbacks.set_tcp_active);
+
+    if (phase() != callbacks.phases.ack_wait) {
+        SetPhase(callbacks.phases.hello_wait);
+        StepResult result = callbacks.receive_remote_hello();
+        if (result == STEP_NOT_MINE) {
+            if (callbacks.fallback_on_not_mine) {
+                return FinishWithFallback(this, callbacks.set_tcp_active);
+            }
+            SetPhase(UNINITIALIZED);
+            return STEP_NOT_MINE;
+        }
+        if (result == STEP_NEED_MORE) {
+            return STEP_NEED_MORE;
+        }
+        if (result == STEP_ERROR) {
+            return FinishWithFailure(this, callbacks.on_failed);
+        }
+        bool enabled = result == STEP_OK;
+
+        if (enabled) {
+            SetPhase(callbacks.phases.prepare_local);
+            result = callbacks.prepare_local();
+            if (result != STEP_OK && result != STEP_FALLBACK) {
+                return FinishWithFailure(this, callbacks.on_failed);
+            }
+            enabled = result == STEP_OK;
+        }
+
+        if (enabled) {
+            SetPhase(callbacks.phases.negotiate);
+            result = callbacks.negotiate_resources();
+            if (result != STEP_OK && result != STEP_FALLBACK) {
+                return FinishWithFailure(this, callbacks.on_failed);
+            }
+            enabled = result == STEP_OK;
+        }
+
+        SetPhase(callbacks.phases.hello_send);
+        if (callbacks.send_local_hello(enabled) != STEP_OK) {
+            return FinishWithFailure(this, callbacks.on_failed);
+        }
+        SetPhase(callbacks.phases.ack_wait);
+        if (!callbacks.blocking) {
+            return STEP_NEED_MORE;
+        }
+    }
+
+    StepResult result = callbacks.receive_ack();
+    if (result == STEP_NEED_MORE) {
+        return STEP_NEED_MORE;
+    }
+    if (result == STEP_ERROR || result == STEP_NOT_MINE) {
+        return FinishWithFailure(this, callbacks.on_failed);
+    }
+    if (result == STEP_FALLBACK) {
+        return FinishWithFallback(this, callbacks.set_tcp_active);
+    }
+
+    callbacks.set_high_speed_active();
+    MarkEstablished();
+    return STEP_OK;
+}
+
 }  // namespace handshake
 }  // namespace brpc
diff --git a/src/brpc/transport_handshake.h b/src/brpc/transport_handshake.h
index 0161b655dc..d84436ff1b 100644
--- a/src/brpc/transport_handshake.h
+++ b/src/brpc/transport_handshake.h
@@ -19,6 +19,7 @@
 #define BRPC_TRANSPORT_HANDSHAKE_H
 
 #include <cstddef>
+#include <functional>
 
 #include "butil/atomicops.h"
 #include "butil/iobuf.h"
@@ -49,6 +50,53 @@ enum Phase {
     FAILED = 0x300,
 };
 
+enum StepResult {
+    STEP_OK = 0,
+    STEP_FALLBACK,
+    STEP_NEED_MORE,
+    STEP_NOT_MINE,
+    STEP_ERROR,
+};
+
+struct HandshakePhases {
+    int prepare_local;
+    int hello_send;
+    int hello_wait;
+    int negotiate;
+    int ack_send;
+    int ack_wait;
+};
+
+// Protocol-specific operations invoked by the common client driver. A
+// callback reports what happened but does not advance the session phase.
+struct ClientHandshakeCallbacks {
+    HandshakePhases phases;
+    std::function<StepResult()> prepare_local;
+    std::function<StepResult()> send_local_hello;
+    std::function<StepResult()> receive_remote_hello;
+    std::function<StepResult()> negotiate_resources;
+    std::function<StepResult(bool)> send_ack;
+    std::function<void()> set_high_speed_active;
+    std::function<void()> set_tcp_active;
+    std::function<void()> on_failed;
+};
+
+// The server driver can operate incrementally (InputMessenger parser) or run
+// through ACK_WAIT in one blocking handshake bthread.
+struct ServerHandshakeCallbacks {
+    HandshakePhases phases;
+    bool blocking;
+    bool fallback_on_not_mine;
+    std::function<StepResult()> receive_remote_hello;
+    std::function<StepResult()> prepare_local;
+    std::function<StepResult()> negotiate_resources;
+    std::function<StepResult(bool)> send_local_hello;
+    std::function<StepResult()> receive_ack;
+    std::function<void()> set_high_speed_active;
+    std::function<void()> set_tcp_active;
+    std::function<void()> on_failed;
+};
+
 // Owns TCP-fd I/O and its readable notification while upgrading a connection.
 // The handshake lifecycle is owned by HandshakeSession below.
 class SocketHandshakeIO {
@@ -121,6 +169,9 @@ class HandshakeSession {
     const SocketHandshakeIO* io() const { return &_io; }
     void NotifyReadable() { _io.NotifyReadable(); }
 
+    StepResult RunClient(const ClientHandshakeCallbacks& callbacks);
+    StepResult RunServer(const ServerHandshakeCallbacks& callbacks);
+
 private:
     SocketHandshakeIO _io;
     butil::atomic<int> _phase;
diff --git a/src/brpc/ubshm/ub_endpoint.cpp b/src/brpc/ubshm/ub_endpoint.cpp
index fe2138fd7c..ac85f75207 100644
--- a/src/brpc/ubshm/ub_endpoint.cpp
+++ b/src/brpc/ubshm/ub_endpoint.cpp
@@ -219,119 +219,120 @@ void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
         << "Start handshake on " << s->_local_side;
 
     uint8_t data[g_ub_hello_msg_len];
-
-    ub_transport->_handshake.SetPhase(C_ALLOC_SHM);
     size_t local_shm_len = (size_t)(FLAGS_data_queue_size) * MB_TO_BYTE;
     SHM local_trx_shm = {NULL, local_shm_len, 0, {0}, (uint32_t)s->fd()};
     auto shm_name_str = butil::endpoint2str(s->local_side());
     const char* shm_name = shm_name_str.c_str();
-    if (ep->AllocateClientResources(&local_trx_shm, shm_name) < 0) {
+    HelloMessage remote_msg{};
+
+    handshake::ClientHandshakeCallbacks callbacks{};
+    callbacks.phases = handshake::HandshakePhases{
+        C_ALLOC_SHM, C_HELLO_SEND, C_HELLO_WAIT,
+        C_MAP_REMOTE_SHM, C_ACK_SEND, 0};
+    callbacks.prepare_local = [&]() {
+        if (ep->AllocateClientResources(&local_trx_shm, shm_name) == 0) {
+            return handshake::STEP_OK;
+        }
         LOG(WARNING) << "Fallback to tcp:" << s->description();
         errno = 0;
-        ub_transport->FallbackToTcp();
-        return NULL;
-    }
-
-    ub_transport->_handshake.SetPhase(C_HELLO_SEND);
-    HelloMessage local_msg{};
-    local_msg.msg_len = g_ub_hello_msg_len;
-    local_msg.hello_ver = g_ub_hello_version;
-    local_msg.impl_ver = g_ub_impl_version;
-    local_msg.len = local_shm_len;
-    memcpy(local_msg.shm_name, local_trx_shm.name, SHM_MAX_NAME_BUFF_LEN);
-    memcpy(data, MAGIC_STR, MAGIC_STR_LEN);
-    local_msg.Serialize((char*)data + MAGIC_STR_LEN);
-    if (ub_transport->_handshake.io()->WriteAll(
-            data, g_ub_hello_msg_len) < 0) {
-        const int saved_errno = errno;
-        PLOG(WARNING) << "Fail to send hello message to server:" << s->description();
-        s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
-                s->description().c_str(), berror(saved_errno));
-        ub_transport->FailHandshake();
-        return NULL;
-    }
-    LOG_IF(INFO, FLAGS_ub_trace_verbose) << "client handshake message : " << local_msg.toString();
-
-    ub_transport->_handshake.SetPhase(C_HELLO_WAIT);
-    if (ub_transport->_handshake.io()->ReadExact(
-            data, MAGIC_STR_LEN) < 0) {
-        const int saved_errno = errno;
-        PLOG(WARNING) << "Fail to get hello message from server:" << s->description();
-        s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
-                s->description().c_str(), berror(saved_errno));
-        ub_transport->FailHandshake();
-        return NULL;
-    }
-    if (memcmp(data, MAGIC_STR, MAGIC_STR_LEN) != 0) {
-        LOG(WARNING) << "Read unexpected data during handshake:" << s->description();
-        s->SetFailed(EPROTO, "Fail to complete ubring handshake from %s: %s",
-                s->description().c_str(), berror(EPROTO));
-        ub_transport->FailHandshake();
-        return NULL;
-    }
-
-    if (ub_transport->_handshake.io()->ReadExact(
-            data, HELLO_MSG_LEN_MIN - MAGIC_STR_LEN) < 0) {
+        return handshake::STEP_FALLBACK;
+    };
+    callbacks.send_local_hello = [&]() {
+        HelloMessage local_msg{};
+        local_msg.msg_len = g_ub_hello_msg_len;
+        local_msg.hello_ver = g_ub_hello_version;
+        local_msg.impl_ver = g_ub_impl_version;
+        local_msg.len = local_shm_len;
+        memcpy(local_msg.shm_name, local_trx_shm.name,
+               SHM_MAX_NAME_BUFF_LEN);
+        memcpy(data, MAGIC_STR, MAGIC_STR_LEN);
+        local_msg.Serialize((char*)data + MAGIC_STR_LEN);
+        if (ub_transport->_handshake.io()->WriteAll(
+                data, g_ub_hello_msg_len) == 0) {
+            LOG_IF(INFO, FLAGS_ub_trace_verbose)
+                << "client handshake message : " << local_msg.toString();
+            return handshake::STEP_OK;
+        }
         const int saved_errno = errno;
-        PLOG(WARNING) << "Fail to get Hello Message from server:" << s->description();
-        s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
-                s->description().c_str(), berror(saved_errno));
-        ub_transport->FailHandshake();
-        return NULL;
-    }
-    HelloMessage remote_msg{};
-    remote_msg.Deserialize(data);
-    if (remote_msg.msg_len < HELLO_MSG_LEN_MIN) {
-        LOG(WARNING) << "Fail to parse Hello Message length from server:"
-                     << s->description();
-        s->SetFailed(EPROTO, "Fail to complete ubring handshake from %s: %s",
-                s->description().c_str(), berror(EPROTO));
-        ub_transport->FailHandshake();
-        return NULL;
-    }
-
-    if (remote_msg.msg_len > HELLO_MSG_LEN_MIN) {
-        // TODO: Read Hello Message customized data
-        // Just for future use, should not happen now
-    }
-
-    if (!HelloNegotiationValid(remote_msg)) {
-        LOG(WARNING) << "Fail to negotiate with server, fallback to tcp:"
+        PLOG(WARNING) << "Fail to send hello message to server:"
+                      << s->description();
+        s->SetFailed(saved_errno,
+                     "Fail to complete ubring handshake from %s: %s",
+                     s->description().c_str(), berror(saved_errno));
+        return handshake::STEP_ERROR;
+    };
+    callbacks.receive_remote_hello = [&]() {
+        if (ub_transport->_handshake.io()->ReadExact(
+                data, MAGIC_STR_LEN) < 0) {
+            const int saved_errno = errno;
+            s->SetFailed(saved_errno,
+                         "Fail to complete ubring handshake from %s: %s",
+                         s->description().c_str(), berror(saved_errno));
+            return handshake::STEP_ERROR;
+        }
+        if (memcmp(data, MAGIC_STR, MAGIC_STR_LEN) != 0) {
+            s->SetFailed(EPROTO,
+                         "Fail to complete ubring handshake from %s: %s",
+                         s->description().c_str(), berror(EPROTO));
+            return handshake::STEP_ERROR;
+        }
+        if (ub_transport->_handshake.io()->ReadExact(
+                data, HELLO_MSG_LEN_MIN - MAGIC_STR_LEN) < 0) {
+            const int saved_errno = errno;
+            s->SetFailed(saved_errno,
+                         "Fail to complete ubring handshake from %s: %s",
+                         s->description().c_str(), berror(saved_errno));
+            return handshake::STEP_ERROR;
+        }
+        remote_msg.Deserialize(data);
+        if (remote_msg.msg_len < HELLO_MSG_LEN_MIN) {
+            s->SetFailed(EPROTO,
+                         "Fail to complete ubring handshake from %s: %s",
+                         s->description().c_str(), berror(EPROTO));
+            return handshake::STEP_ERROR;
+        }
+        if (!HelloNegotiationValid(remote_msg)) {
+            LOG(WARNING) << "Fail to negotiate with server, fallback to tcp:"
+                         << s->description();
+            return handshake::STEP_FALLBACK;
+        }
+        return handshake::STEP_OK;
+    };
+    callbacks.negotiate_resources = [&]() {
+        if (ep->_ub_ring->UbrMapRemoteShm(&local_trx_shm, shm_name) == 0) {
+            return handshake::STEP_OK;
+        }
+        LOG(WARNING) << "Fail to map the remote shm, fallback to tcp:"
                      << s->description();
-        ub_transport->_ub_state = UBShmTransport::UB_OFF;
-    } else {
-        ub_transport->_handshake.SetPhase(C_MAP_REMOTE_SHM);
-        if (ep->_ub_ring->UbrMapRemoteShm(&local_trx_shm, shm_name) < 0) {
-            LOG(WARNING) << "Fail to map the remote shm, fallback to tcp:" << s->description();
-            ub_transport->_ub_state = UBShmTransport::UB_OFF;
-        } else {
-            ub_transport->_ub_state = UBShmTransport::UB_ON;
+        return handshake::STEP_FALLBACK;
+    };
+    callbacks.send_ack = [&](bool enabled) {
+        uint32_t* flags = (uint32_t*)data;
+        *flags = butil::HostToNet32(enabled ? ACK_MSG_UB_OK : 0);
+        if (ub_transport->_handshake.io()->WriteAll(data, ACK_MSG_LEN) == 0) {
+            return handshake::STEP_OK;
         }
-    }
-
-    ub_transport->_handshake.SetPhase(C_ACK_SEND);
-    uint32_t flags = 0;
-    if (ub_transport->_ub_state != UBShmTransport::UB_OFF) {
-        flags |= ACK_MSG_UB_OK;
-    }
-    uint32_t* tmp = (uint32_t*)data;
-    *tmp = butil::HostToNet32(flags);
-    if (ub_transport->_handshake.io()->WriteAll(data, ACK_MSG_LEN) < 0) {
         const int saved_errno = errno;
-        PLOG(WARNING) << "Fail to send Ack Message to server:" << s->description();
-        s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
-                s->description().c_str(), berror(saved_errno));
-        ub_transport->FailHandshake();
-        return NULL;
-    }
+        s->SetFailed(saved_errno,
+                     "Fail to complete ubring handshake from %s: %s",
+                     s->description().c_str(), berror(saved_errno));
+        return handshake::STEP_ERROR;
+    };
+    callbacks.set_high_speed_active = [ub_transport]() {
+        ub_transport->SetHighSpeedAvailable(true);
+    };
+    callbacks.set_tcp_active = [ub_transport]() {
+        ub_transport->SetHighSpeedAvailable(false);
+    };
+    callbacks.on_failed = []() {};
 
-    if (ub_transport->_ub_state == UBShmTransport::UB_ON) {
-        ub_transport->ActivateHighSpeed();
+    const handshake::StepResult result =
+        ub_transport->_handshake.RunClient(callbacks);
+    if (result == handshake::STEP_OK) {
         ep->_ub_ring->UbrUnlinkLocalShm();
         LOG_IF(INFO, FLAGS_ub_trace_verbose) 
             << "Client handshake ends (use ubring) on " << s->description();
-    } else {
-        ub_transport->FallbackToTcp();
+    } else if (result == handshake::STEP_FALLBACK) {
         LOG_IF(INFO, FLAGS_ub_trace_verbose) 
             << "Client handshake ends (use tcp) on " << s->description();
     }
@@ -350,65 +351,59 @@ void* UBShmTransport::ProcessHandshakeAtServer(void* arg) {
         << "Start handshake on " << s->description();
 
     uint8_t data[g_ub_hello_msg_len];
-
-    ub_transport->_handshake.SetPhase(S_HELLO_WAIT);
-    if (ub_transport->_handshake.io()->ReadExact(
-            data, MAGIC_STR_LEN) < 0) {
-        const int saved_errno = errno;
-        PLOG(WARNING) << "Fail to read Hello Message from client:" << s->description() << " " << s->_remote_side;
-        s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
-                s->description().c_str(), berror(saved_errno));
-        ub_transport->FailHandshake();
-        return NULL;
-    }
-    if (memcmp(data, MAGIC_STR, MAGIC_STR_LEN) != 0) {
-        LOG_IF(INFO, FLAGS_ub_trace_verbose) << "It seems that the "
-            << "client does not use RDMA, fallback to TCP:"
-            << s->description();
-        s->_read_buf.append(data, MAGIC_STR_LEN);
-        ub_transport->FallbackToTcp();
-        ub_transport->TryReadOnTcp();
-        return NULL;
-    }
-
-    if (ub_transport->_handshake.io()->ReadExact(
-            data, g_ub_hello_msg_len - MAGIC_STR_LEN) < 0) {
-        const int saved_errno = errno;
-        PLOG(WARNING) << "Fail to read Hello Message from client:" << s->description();
-        s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
-                s->description().c_str(), berror(saved_errno));
-        ub_transport->FailHandshake();
-        return NULL;
-    }
-
     HelloMessage remote_msg{};
-    remote_msg.Deserialize(data);
-    LOG_IF(INFO, FLAGS_ub_trace_verbose) << "server receive handshake message : " << remote_msg.toString();
-    if (remote_msg.msg_len < HELLO_MSG_LEN_MIN) {
-        LOG(WARNING) << "Fail to parse Hello Message length from client:"
-                     << s->description();
-        s->SetFailed(EPROTO, "Fail to complete ubring handshake from %s: %s",
-                s->description().c_str(), berror(EPROTO));
-        ub_transport->FailHandshake();
-        return NULL;
-    }
-    if (remote_msg.msg_len > HELLO_MSG_LEN_MIN) {
-        // TODO: Read Hello Message customized header
-        // Just for future use, should not happen now
-    }
-
-    if (!HelloNegotiationValid(remote_msg)) {
-        LOG(WARNING) << "Fail to negotiate with client, fallback to tcp:"
-                     << s->description();
-        ub_transport->_ub_state = UBShmTransport::UB_OFF;
-    } else {
-        ub_transport->_handshake.SetPhase(S_ALLOC_SHM);
-        ubring::SHM remote_trx_shm = {NULL, remote_msg.len, 0, {0}, (uint32_t)ep->_socket->fd()};
+    bool local_enabled = false;
+
+    handshake::ServerHandshakeCallbacks callbacks{};
+    callbacks.phases = handshake::HandshakePhases{
+        S_ALLOC_SHM, S_HELLO_SEND, S_HELLO_WAIT,
+        S_ALLOC_SHM, 0, S_ACK_WAIT};
+    callbacks.blocking = true;
+    callbacks.fallback_on_not_mine = true;
+    callbacks.receive_remote_hello = [&]() {
+        if (ub_transport->_handshake.io()->ReadExact(
+                data, MAGIC_STR_LEN) < 0) {
+            const int saved_errno = errno;
+            s->SetFailed(saved_errno,
+                         "Fail to complete ubring handshake from %s: %s",
+                         s->description().c_str(), berror(saved_errno));
+            return handshake::STEP_ERROR;
+        }
+        if (memcmp(data, MAGIC_STR, MAGIC_STR_LEN) != 0) {
+            s->_read_buf.append(data, MAGIC_STR_LEN);
+            return handshake::STEP_NOT_MINE;
+        }
+        if (ub_transport->_handshake.io()->ReadExact(
+                data, g_ub_hello_msg_len - MAGIC_STR_LEN) < 0) {
+            const int saved_errno = errno;
+            s->SetFailed(saved_errno,
+                         "Fail to complete ubring handshake from %s: %s",
+                         s->description().c_str(), berror(saved_errno));
+            return handshake::STEP_ERROR;
+        }
+        remote_msg.Deserialize(data);
+        LOG_IF(INFO, FLAGS_ub_trace_verbose)
+            << "server receive handshake message : " << remote_msg.toString();
+        if (remote_msg.msg_len < HELLO_MSG_LEN_MIN) {
+            s->SetFailed(EPROTO,
+                         "Fail to complete ubring handshake from %s: %s",
+                         s->description().c_str(), berror(EPROTO));
+            return handshake::STEP_ERROR;
+        }
+        if (!HelloNegotiationValid(remote_msg)) {
+            return handshake::STEP_FALLBACK;
+        }
+        return handshake::STEP_OK;
+    };
+    callbacks.prepare_local = [&]() {
+        ubring::SHM remote_trx_shm = {
+            NULL, remote_msg.len, 0, {0}, (uint32_t)ep->_socket->fd()};
         strncpy(remote_trx_shm.name, remote_msg.shm_name, SHM_MAX_NAME_BUFF_LEN);
 
         size_t local_shm_len = (size_t)(FLAGS_data_queue_size) * MB_TO_BYTE;
         // server-side shared memory name
-        ubring::SHM local_trx_shm = {NULL, local_shm_len, 0, {0}, (uint32_t)ep->_socket->fd()};
+        ubring::SHM local_trx_shm = {
+            NULL, local_shm_len, 0, {0}, (uint32_t)ep->_socket->fd()};
         char client_name[SHM_MAX_NAME_BUFF_LEN];
         strncpy(client_name, remote_msg.shm_name, SHM_MAX_NAME_BUFF_LEN);
 
@@ -420,72 +415,86 @@ void* UBShmTransport::ProcessHandshakeAtServer(void* arg) {
             client_name, SERVER_SHM_NAME_SUFFIX);
         if (UNLIKELY(result < 0)) {
             LOG(WARNING) << "Copy client shared memory name failed, ret=" << result;
-            ub_transport->_ub_state = UBShmTransport::UB_OFF;
+            return handshake::STEP_FALLBACK;
         }
-        if (result >= 0 && ep->AllocateServerResources(&remote_trx_shm, &local_trx_shm) < 0) {
+        if (ep->AllocateServerResources(
+                &remote_trx_shm, &local_trx_shm) < 0) {
             LOG(WARNING) << "Fail to allocate ub resources, fallback to tcp:"
                          << s->description();
-            ub_transport->_ub_state = UBShmTransport::UB_OFF;
+            return handshake::STEP_FALLBACK;
+        }
+        return handshake::STEP_OK;
+    };
+    callbacks.negotiate_resources = []() {
+        return handshake::STEP_OK;
+    };
+    callbacks.send_local_hello = [&](bool enabled) {
+        local_enabled = enabled;
+        HelloMessage local_msg{};
+        local_msg.msg_len = g_ub_hello_msg_len;
+        if (enabled) {
+            local_msg.hello_ver = g_ub_hello_version;
+            local_msg.impl_ver = g_ub_impl_version;
+            local_msg.len = (FLAGS_data_queue_size) * MB_TO_BYTE;
+            memcpy(local_msg.shm_name, remote_msg.shm_name,
+                   SHM_MAX_NAME_BUFF_LEN);
+        }
+        memcpy(data, MAGIC_STR, MAGIC_STR_LEN);
+        local_msg.Serialize((char*)data + MAGIC_STR_LEN);
+        if (ub_transport->_handshake.io()->WriteAll(
+                data, g_ub_hello_msg_len) == 0) {
+            return handshake::STEP_OK;
         }
-    }
-
-    ub_transport->_handshake.SetPhase(S_HELLO_SEND);
-    HelloMessage local_msg{};
-    local_msg.msg_len = g_ub_hello_msg_len;
-    if (ub_transport->_ub_state == UBShmTransport::UB_OFF) {
-        local_msg.impl_ver = 0;
-        local_msg.hello_ver = 0;
-    } else {
-        local_msg.hello_ver = g_ub_hello_version;
-        local_msg.impl_ver = g_ub_impl_version;
-        local_msg.len = (FLAGS_data_queue_size) * MB_TO_BYTE;
-        memcpy(local_msg.shm_name, remote_msg.shm_name, SHM_MAX_NAME_BUFF_LEN);
-    }
-    memcpy(data, MAGIC_STR, MAGIC_STR_LEN);
-    local_msg.Serialize((char*)data + MAGIC_STR_LEN);
-    if (ub_transport->_handshake.io()->WriteAll(
-            data, g_ub_hello_msg_len) < 0) {
-        const int saved_errno = errno;
-        PLOG(WARNING) << "Fail to send Hello Message to client:" << s->description();
-        s->SetFailed(saved_errno, "Fail to complete ub handshake from %s: %s",
-                s->description().c_str(), berror(saved_errno));
-        ub_transport->FailHandshake();
-        return NULL;
-    }
-
-    ub_transport->_handshake.SetPhase(S_ACK_WAIT);
-    if (ub_transport->_handshake.io()->ReadExact(
-            data, ACK_MSG_LEN) < 0) {
         const int saved_errno = errno;
-        PLOG(WARNING) << "Fail to read ack message from client:" << s->description();
-        s->SetFailed(saved_errno, "Fail to complete ubring handshake from %s: %s",
-                s->description().c_str(), berror(saved_errno));
-        ub_transport->FailHandshake();
-        return NULL;
-    }
-
-    uint32_t* tmp = (uint32_t*)data;
-    uint32_t flags = butil::NetToHost32(*tmp);
-    if (flags & ACK_MSG_UB_OK) {
-        if (ub_transport->_ub_state == UBShmTransport::UB_OFF) {
-            LOG(WARNING) << "Fail to parse Hello Message length from client:"
-                         << s->description();
-            s->SetFailed(EPROTO, "Fail to complete ub handshake from %s: %s",
-                    s->description().c_str(), berror(EPROTO));
-            ub_transport->FailHandshake();
-            return NULL;
-        } else {
-            ub_transport->ActivateHighSpeed();
-            ep->_ub_ring->UbrUnlinkLocalShm();
-            LOG_IF(INFO, FLAGS_ub_trace_verbose) 
-                << "Server handshake ends (use ubring) on " << s->description();
+        s->SetFailed(saved_errno,
+                     "Fail to complete ub handshake from %s: %s",
+                     s->description().c_str(), berror(saved_errno));
+        return handshake::STEP_ERROR;
+    };
+    callbacks.receive_ack = [&]() {
+        if (ub_transport->_handshake.io()->ReadExact(
+                data, ACK_MSG_LEN) < 0) {
+            const int saved_errno = errno;
+            s->SetFailed(saved_errno,
+                         "Fail to complete ubring handshake from %s: %s",
+                         s->description().c_str(), berror(saved_errno));
+            return handshake::STEP_ERROR;
         }
-    } else {
-        ub_transport->FallbackToTcp();
+        uint32_t* flags = (uint32_t*)data;
+        const bool client_enabled =
+            (butil::NetToHost32(*flags) & ACK_MSG_UB_OK) != 0;
+        if (!client_enabled) {
+            return handshake::STEP_FALLBACK;
+        }
+        if (!local_enabled) {
+            s->SetFailed(EPROTO,
+                         "Fail to complete ub handshake from %s: %s",
+                         s->description().c_str(), berror(EPROTO));
+            return handshake::STEP_ERROR;
+        }
+        return handshake::STEP_OK;
+    };
+    callbacks.set_high_speed_active = [ub_transport]() {
+        ub_transport->SetHighSpeedAvailable(true);
+    };
+    callbacks.set_tcp_active = [ub_transport]() {
+        ub_transport->SetHighSpeedAvailable(false);
+    };
+    callbacks.on_failed = []() {};
+
+    const handshake::StepResult result =
+        ub_transport->_handshake.RunServer(callbacks);
+    if (result == handshake::STEP_OK) {
+        ep->_ub_ring->UbrUnlinkLocalShm();
+        LOG_IF(INFO, FLAGS_ub_trace_verbose)
+            << "Server handshake ends (use ubring) on " << s->description();
+    } else if (result == handshake::STEP_FALLBACK) {
         LOG_IF(INFO, FLAGS_ub_trace_verbose) 
             << "Server handshake ends (use tcp) on " << s->description();
     }
-    ub_transport->TryReadOnTcp();
+    if (result != handshake::STEP_ERROR) {
+        ub_transport->TryReadOnTcp();
+    }
 
     return NULL;
 }
diff --git a/src/brpc/upgrade_transport.cpp b/src/brpc/upgrade_transport.cpp
index a5c6e87575..e694b8f134 100644
--- a/src/brpc/upgrade_transport.cpp
+++ b/src/brpc/upgrade_transport.cpp
@@ -68,21 +68,12 @@ int UpgradeTransport::WaitEpollOut(butil::atomic<int>* epollout_butex,
     return _tcp_transport->WaitEpollOut(epollout_butex, pollin, duetime);
 }
 
-void UpgradeTransport::ActivateHighSpeed() {
-    SetHighSpeedAvailable(true);
-    _handshake.MarkEstablished();
-}
-
 void UpgradeTransport::FallbackToTcp() {
     _handshake.PublishFallback([this]() {
         SetHighSpeedAvailable(false);
     });
 }
 
-void UpgradeTransport::FailHandshake() {
-    _handshake.MarkFailed();
-}
-
 void UpgradeTransport::OnNewDataFromTcp(Socket* socket) {
     static_cast<UpgradeTransport*>(socket->_transport.get())->ProcessTcpEvent();
 }
diff --git a/src/brpc/upgrade_transport.h b/src/brpc/upgrade_transport.h
index 5cd5d8237e..dba9c4b8a9 100644
--- a/src/brpc/upgrade_transport.h
+++ b/src/brpc/upgrade_transport.h
@@ -49,9 +49,7 @@ class UpgradeTransport : public Transport {
                               const OnEdgeTrigger& default_on_edge);
     void ResetUpgradeTransport();
 
-    void ActivateHighSpeed();
     void FallbackToTcp();
-    void FailHandshake();
     void TryReadOnTcp();
 
     virtual void SetHighSpeedAvailable(bool available) = 0;
diff --git a/test/brpc_transport_handshake_unittest.cpp b/test/brpc_transport_handshake_unittest.cpp
index 7a47860fc4..f7f08d4551 100644
--- a/test/brpc_transport_handshake_unittest.cpp
+++ b/test/brpc_transport_handshake_unittest.cpp
@@ -17,6 +17,8 @@
 
 #include <gtest/gtest.h>
 
+#include <string>
+
 #include "brpc/transport_handshake.h"
 
 namespace brpc {
@@ -45,5 +47,178 @@ TEST(TransportHandshakeTest, reset_clears_terminal_state) {
     ASSERT_EQ(0, handshake.protocol_version());
 }
 
+TEST(TransportHandshakeTest, client_driver_runs_common_sequence) {
+    HandshakeSession session;
+    std::string calls;
+    bool high_speed_active = false;
+
+    ClientHandshakeCallbacks callbacks{};
+    callbacks.phases = HandshakePhases{1, 2, 3, 4, 5, 6};
+    callbacks.prepare_local = [&]() {
+        calls += "prepare ";
+        return STEP_OK;
+    };
+    callbacks.send_local_hello = [&]() {
+        calls += "send_hello ";
+        return STEP_OK;
+    };
+    callbacks.receive_remote_hello = [&]() {
+        calls += "recv_hello ";
+        return STEP_OK;
+    };
+    callbacks.negotiate_resources = [&]() {
+        calls += "negotiate ";
+        return STEP_OK;
+    };
+    callbacks.send_ack = [&](bool enabled) {
+        EXPECT_TRUE(enabled);
+        calls += "send_ack ";
+        return STEP_OK;
+    };
+    callbacks.set_high_speed_active = [&]() {
+        high_speed_active = true;
+        calls += "activate";
+    };
+    callbacks.set_tcp_active = []() {};
+    callbacks.on_failed = []() {};
+
+    ASSERT_EQ(STEP_OK, session.RunClient(callbacks));
+    ASSERT_EQ("prepare send_hello recv_hello negotiate send_ack activate",
+              calls);
+    ASSERT_TRUE(high_speed_active);
+    ASSERT_EQ(ESTABLISHED, session.phase());
+}
+
+TEST(TransportHandshakeTest, client_driver_falls_back_after_remote_hello) {
+    HandshakeSession session;
+    bool ack_enabled = true;
+    bool tcp_active = false;
+
+    ClientHandshakeCallbacks callbacks{};
+    callbacks.phases = HandshakePhases{1, 2, 3, 4, 5, 6};
+    callbacks.prepare_local = []() { return STEP_OK; };
+    callbacks.send_local_hello = []() { return STEP_OK; };
+    callbacks.receive_remote_hello = []() { return STEP_FALLBACK; };
+    callbacks.negotiate_resources = []() {
+        ADD_FAILURE() << "resource negotiation must be skipped";
+        return STEP_ERROR;
+    };
+    callbacks.send_ack = [&](bool enabled) {
+        ack_enabled = enabled;
+        return STEP_OK;
+    };
+    callbacks.set_high_speed_active = []() {};
+    callbacks.set_tcp_active = [&]() { tcp_active = true; };
+    callbacks.on_failed = []() {};
+
+    ASSERT_EQ(STEP_FALLBACK, session.RunClient(callbacks));
+    ASSERT_FALSE(ack_enabled);
+    ASSERT_TRUE(tcp_active);
+    ASSERT_EQ(FALLBACK_TCP, session.phase());
+}
+
+TEST(TransportHandshakeTest, server_driver_resumes_at_ack_wait) {
+    HandshakeSession session;
+    int hello_calls = 0;
+    int ack_calls = 0;
+    bool high_speed_active = false;
+
+    ServerHandshakeCallbacks callbacks{};
+    callbacks.phases = HandshakePhases{11, 12, 13, 14, 15, 16};
+    callbacks.blocking = false;
+    callbacks.fallback_on_not_mine = false;
+    callbacks.receive_remote_hello = [&]() {
+        ++hello_calls;
+        return STEP_OK;
+    };
+    callbacks.prepare_local = []() { return STEP_OK; };
+    callbacks.negotiate_resources = []() { return STEP_OK; };
+    callbacks.send_local_hello = [](bool enabled) {
+        EXPECT_TRUE(enabled);
+        return STEP_OK;
+    };
+    callbacks.receive_ack = [&]() {
+        ++ack_calls;
+        return STEP_OK;
+    };
+    callbacks.set_high_speed_active = [&]() {
+        high_speed_active = true;
+    };
+    callbacks.set_tcp_active = []() {};
+    callbacks.on_failed = []() {};
+
+    ASSERT_EQ(STEP_NEED_MORE, session.RunServer(callbacks));
+    ASSERT_EQ(16, session.phase());
+    ASSERT_EQ(1, hello_calls);
+    ASSERT_EQ(0, ack_calls);
+
+    ASSERT_EQ(STEP_OK, session.RunServer(callbacks));
+    ASSERT_EQ(1, hello_calls);
+    ASSERT_EQ(1, ack_calls);
+    ASSERT_TRUE(high_speed_active);
+    ASSERT_EQ(ESTABLISHED, session.phase());
+}
+
+TEST(TransportHandshakeTest, server_driver_runs_blocking_handshake) {
+    HandshakeSession session;
+    std::string calls;
+
+    ServerHandshakeCallbacks callbacks{};
+    callbacks.phases = HandshakePhases{11, 12, 13, 14, 15, 16};
+    callbacks.blocking = true;
+    callbacks.fallback_on_not_mine = true;
+    callbacks.receive_remote_hello = [&]() {
+        calls += "recv_hello ";
+        return STEP_OK;
+    };
+    callbacks.prepare_local = [&]() {
+        calls += "prepare ";
+        return STEP_OK;
+    };
+    callbacks.negotiate_resources = [&]() {
+        calls += "negotiate ";
+        return STEP_OK;
+    };
+    callbacks.send_local_hello = [&](bool enabled) {
+        EXPECT_TRUE(enabled);
+        calls += "send_hello ";
+        return STEP_OK;
+    };
+    callbacks.receive_ack = [&]() {
+        calls += "recv_ack ";
+        return STEP_OK;
+    };
+    callbacks.set_high_speed_active = [&]() { calls += "activate"; };
+    callbacks.set_tcp_active = []() {};
+    callbacks.on_failed = []() {};
+
+    ASSERT_EQ(STEP_OK, session.RunServer(callbacks));
+    ASSERT_EQ("recv_hello prepare negotiate send_hello recv_ack activate",
+              calls);
+    ASSERT_EQ(ESTABLISHED, session.phase());
+}
+
+TEST(TransportHandshakeTest, server_driver_falls_back_for_other_protocol) {
+    HandshakeSession session;
+    bool tcp_active = false;
+
+    ServerHandshakeCallbacks callbacks{};
+    callbacks.phases = HandshakePhases{11, 12, 13, 14, 15, 16};
+    callbacks.blocking = true;
+    callbacks.fallback_on_not_mine = true;
+    callbacks.receive_remote_hello = []() { return STEP_NOT_MINE; };
+    callbacks.prepare_local = []() { return STEP_ERROR; };
+    callbacks.negotiate_resources = []() { return STEP_ERROR; };
+    callbacks.send_local_hello = [](bool) { return STEP_ERROR; };
+    callbacks.receive_ack = []() { return STEP_ERROR; };
+    callbacks.set_high_speed_active = []() {};
+    callbacks.set_tcp_active = [&]() { tcp_active = true; };
+    callbacks.on_failed = []() {};
+
+    ASSERT_EQ(STEP_FALLBACK, session.RunServer(callbacks));
+    ASSERT_TRUE(tcp_active);
+    ASSERT_EQ(FALLBACK_TCP, session.phase());
+}
+
 }  // namespace handshake
 }  // namespace brpc

From 7cb745eeadffdbb7dc94281c3386dde9109b2572 Mon Sep 17 00:00:00 2001
From: Gzure <740684863@qq.com>
Date: Tue, 18 Aug 2026 16:56:18 +0800
Subject: [PATCH 05/11] Move handshake adapters to transport layer

---
 CMakeLists.txt                                |   2 +-
 docs/cn/handshake_common_design.md            |  82 ++++---
 ...de_transport.cpp => adapter_transport.cpp} |  24 +-
 ...pgrade_transport.h => adapter_transport.h} |  16 +-
 src/brpc/input_messenger.h                    |   4 +-
 src/brpc/policy/rdma_handshake_protocol.cpp   |   2 +-
 src/brpc/rdma/rdma_endpoint.cpp               |  72 +++---
 src/brpc/rdma/rdma_endpoint.h                 |  80 ++-----
 src/brpc/{rdma => }/rdma_handshake.cpp        | 176 +++++++-------
 src/brpc/{rdma => }/rdma_handshake.h          |  99 ++++----
 src/brpc/{rdma => }/rdma_handshake.proto      |   0
 .../{rdma => }/rdma_handshake_constants.h     |   6 +-
 src/brpc/{rdma => }/rdma_handshake_server.cpp |  10 +-
 src/brpc/{rdma => }/rdma_handshake_server.h   |   6 +-
 src/brpc/rdma_transport.cpp                   |  32 +--
 src/brpc/rdma_transport.h                     |   6 +-
 src/brpc/socket.h                             |  12 +-
 src/brpc/transport_handshake.cpp              |   7 +-
 src/brpc/transport_handshake.h                |   7 +-
 src/brpc/ubshm/ub_endpoint.cpp                |   1 -
 src/brpc/ubshm_transport.cpp                  |   4 +-
 src/brpc/ubshm_transport.h                    |   4 +-
 test/brpc_rdma_unittest.cpp                   | 225 +++++++++---------
 test/brpc_transport_handshake_unittest.cpp    |   9 +-
 24 files changed, 424 insertions(+), 462 deletions(-)
 rename src/brpc/{upgrade_transport.cpp => adapter_transport.cpp} (87%)
 rename src/brpc/{upgrade_transport.h => adapter_transport.h} (88%)
 rename src/brpc/{rdma => }/rdma_handshake.cpp (79%)
 rename src/brpc/{rdma => }/rdma_handshake.h (64%)
 rename src/brpc/{rdma => }/rdma_handshake.proto (100%)
 rename src/brpc/{rdma => }/rdma_handshake_constants.h (94%)
 rename src/brpc/{rdma => }/rdma_handshake_server.cpp (96%)
 rename src/brpc/{rdma => }/rdma_handshake_server.h (92%)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9419ac3a76..a4df60cfd0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -615,7 +615,7 @@ set(PROTO_FILES idl_options.proto
                 brpc/trackme.proto
                 brpc/streaming_rpc_meta.proto
                 brpc/proto_base.proto
-                brpc/rdma/rdma_handshake.proto)
+                brpc/rdma_handshake.proto)
 file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/output/include/brpc)
 set(PROTOC_FLAGS ${PROTOC_FLAGS} -I${PROTOBUF_INCLUDE_DIR})
 compile_proto(PROTO_HDRS PROTO_SRCS ${PROJECT_BINARY_DIR}
diff --git a/docs/cn/handshake_common_design.md b/docs/cn/handshake_common_design.md
index 743035f007..83b6f91b84 100644
--- a/docs/cn/handshake_common_design.md
+++ b/docs/cn/handshake_common_design.md
@@ -43,9 +43,9 @@ RDMA 支持：
 
 相关代码：
 
-- `src/brpc/rdma/rdma_handshake.h`
-- `src/brpc/rdma/rdma_handshake.cpp`
-- `src/brpc/rdma/rdma_handshake_server.cpp`
+- `src/brpc/rdma_handshake.h`
+- `src/brpc/rdma_handshake.cpp`
+- `src/brpc/rdma_handshake_server.cpp`
 
 ### 2.2 URMA
 
@@ -118,9 +118,12 @@ Hello 中携带：
 
 ```text
 src/brpc/
-    upgrade_transport.h/.cpp     # TCP-first 路由、升级成功/回退发布
+    adapter_transport.h/.cpp     # TCP-first 路由、适配器切换与状态发布
     transport_handshake.h/.cpp   # HandshakeSession 与 SocketHandshakeIO
-    rdma_transport.h/.cpp        # RDMA 协议状态机与 Endpoint adapter
+    rdma_handshake.h/.cpp        # RDMA v2/v3 wire adapter
+    rdma_handshake_server.h/.cpp # RDMA 标准 server parser/fallback
+    rdma_handshake.proto         # RDMA v3 wire message
+    rdma_transport.h/.cpp        # RDMA 握手回调与 Endpoint adapter
     ubshm_transport.h/.cpp       # UBSHM 协议状态机与 Endpoint adapter
 ```
 
@@ -128,7 +131,7 @@ src/brpc/
 
 ```mermaid
 flowchart TB
-    S["Socket"] --> UT["UpgradeTransport\nTCP-first 路由与状态发布"]
+    S["Socket"] --> UT["AdapterTransport\nTCP-first 路由与状态发布"]
     UT --> TCP["TcpTransport\n默认数据面 / fallback"]
     UT --> HS["HandshakeSession\nclient/server driver + lifecycle"]
     HS --> IO["SocketHandshakeIO\nReadExact / WriteAll / readable butex"]
@@ -140,16 +143,16 @@ flowchart TB
     BA --> BE["UBShmEndpoint\nUBRing / Shared Memory"]
 ```
 
-`UpgradeTransport` 决定当前数据走 TCP 还是高速 Endpoint；`HandshakeSession` 驱动一次升级尝试的公共步骤；具体 adapter 通过回调完成 Hello/ACK wire codec 和资源协商。Endpoint 不持有 TCP Transport，也不执行 TCP fd 读写。
+`AdapterTransport` 决定当前数据走 TCP 还是高速 Endpoint；`HandshakeSession` 驱动一次升级尝试的公共步骤；具体 adapter 通过回调完成 Hello/ACK wire codec 和资源协商。Endpoint 不持有 TCP Transport，也不执行 TCP fd 读写。
 
 ## 4.1 选定架构：Handshake 位于 Transport 层
 
-默认先建立 TCP 连接，客户端可以请求升级到 RDMA、URMA 或 UBSHM。握手、升级决策、fallback 和 active transport 选择全部由 `UpgradeTransport` 负责。
+默认先建立 TCP 连接，客户端可以请求升级到 RDMA、URMA 或 UBSHM。握手、升级决策、fallback 和 active transport 选择全部由 `AdapterTransport` 负责。
 
 ```mermaid
 flowchart TB
     Socket["Socket"] --> T["RdmaTransport / UrmaTransport / UBShmTransport"]
-    T -. "继承" .-> UT["UpgradeTransport"]
+    T -. "继承" .-> UT["AdapterTransport"]
     UT --> TCP["TcpTransport\n默认控制面与 TCP 数据面"]
     UT --> HS["HandshakeSession\n连接协商 / 版本 / ACK / fallback"]
     HS --> IO["SocketHandshakeIO"]
@@ -172,7 +175,7 @@ flowchart TB
 ```mermaid
 sequenceDiagram
     participant C as Client
-    participant T as UpgradeTransport
+    participant T as AdapterTransport
     participant TCP as TcpTransport
     participant H as HandshakeSession
     participant E as High-speed Endpoint
@@ -206,7 +209,7 @@ sequenceDiagram
 ```mermaid
 sequenceDiagram
     participant TCP as TcpTransport
-    participant T as UpgradeTransport
+    participant T as AdapterTransport
     participant H as HandshakeSession
     participant E as Selected Endpoint
     participant IM as InputMessenger
@@ -474,7 +477,7 @@ server 解析必须保留 `NEED_MORE_DATA`：
 ```text
 BuildHello -> FillLocalRdmaHello
 ParseHello -> ValidRdmaHello + TranslateHello
-Negotiate  -> ApplyRemoteHello + BringUpQp
+Negotiate  -> ApplyRemoteInfo + BringUpQp
 BuildAck   -> RDMA ACK
 ```
 
@@ -493,7 +496,7 @@ BuildAck   -> RDMA ACK
 ```text
 BuildHello -> FillLocalHelloV2/FillLocalHelloV3
 ParseHello -> ValidHello + ParsedHello
-Negotiate  -> ApplyRemoteHello + ImportPeer
+Negotiate  -> ApplyRemoteInfo + ImportPeer
 BuildAck   -> URMA ACK
 ```
 
@@ -521,22 +524,30 @@ UBSHM 是最适合优先迁移的实现，因为它只有固定长度 v2 协议
 
 ## 8. 与现有 Endpoint 的关系
 
-不建议让 `RdmaEndpoint`、`UrmaEndpoint`、`UBShmEndpoint` 继承一个包含大量虚函数的“大 Endpoint 基类”。更合适的方式是组合：
+不建议让 `RdmaEndpoint`、`UrmaEndpoint`、`UBShmEndpoint` 继承一个包含大量虚函数的“大 Endpoint 基类”。握手组件组合在 Transport 层，Endpoint 只暴露资源接口：
 
 ```cpp
-class RdmaEndpoint {
+class RdmaTransport : public AdapterTransport {
     handshake::HandshakeSession _handshake;
-    RdmaHandshakeAdapter _handshake_adapter;
+    RdmaEndpoint* _endpoint;
+    // 每次升级尝试创建一个 RdmaHandshakeAdapter。
 };
 
-class UrmaEndpoint {
+class UrmaTransport : public AdapterTransport {
     handshake::HandshakeSession _handshake;
-    UrmaHandshakeAdapter _handshake_adapter;
+    UrmaEndpoint* _endpoint;
+    // 每次升级尝试创建一个 UrmaHandshakeAdapter。
 };
 
-class UBShmEndpoint {
+class UBShmTransport : public AdapterTransport {
     handshake::HandshakeSession _handshake;
-    UBShmHandshakeAdapter _handshake_adapter;
+    UBShmEndpoint* _endpoint;
+    // 每次升级尝试创建一个 UBShmHandshakeAdapter。
+};
+
+class RdmaEndpoint {
+    RdmaResource* _resource;
+    // QP/CQ/MR and data path only.
 };
 ```
 
@@ -546,10 +557,9 @@ Endpoint 仍然拥有：
 - transport-specific resource；
 - endpoint state 的业务动作；
 - data path；
-- InputMessenger 回调；
 - transport-specific error handling。
 
-公共 driver 只拥有握手阶段和 protocol callback，不拥有 endpoint 生命周期。
+`AdapterTransport`/具体 Transport 拥有 TCP 路由、握手阶段、protocol callback 和 Endpoint 生命周期；公共 driver 不直接依赖 Endpoint 类型。
 
 ## 9. 兼容性和安全约束
 
@@ -703,13 +713,13 @@ RDMA/URMA/UBSHM 的长度字段并不完全相同。规避：使用 `FrameSpec::
 
 ## 14. 当前实现边界与后续迁移
 
-当前实现已经引入 `UpgradeTransport` 和 `HandshakeSession`，类关系如下：
+当前实现已经引入 `AdapterTransport` 和 `HandshakeSession`，类关系如下：
 
 ```mermaid
 classDiagram
     class Transport
     class TcpTransport
-    class UpgradeTransport {
+    class AdapterTransport {
         -HandshakeSession handshake
         -TcpTransport tcp_transport
         +CutFromIOBuf()
@@ -728,21 +738,23 @@ classDiagram
         +MarkFailed()
     }
     class RdmaTransport
+    class RdmaHandshakeAdapter
     class UBShmTransport
     class HighSpeedEndpoint
 
     Transport <|-- TcpTransport
-    Transport <|-- UpgradeTransport
-    UpgradeTransport <|-- RdmaTransport
-    UpgradeTransport <|-- UBShmTransport
-    UpgradeTransport *-- TcpTransport
-    UpgradeTransport *-- HandshakeSession
+    Transport <|-- AdapterTransport
+    AdapterTransport <|-- RdmaTransport
+    AdapterTransport <|-- UBShmTransport
+    AdapterTransport *-- TcpTransport
+    AdapterTransport *-- HandshakeSession
     HandshakeSession *-- SocketHandshakeIO
+    RdmaTransport --> RdmaHandshakeAdapter
     RdmaTransport --> HighSpeedEndpoint
     UBShmTransport --> HighSpeedEndpoint
 ```
 
-`UpgradeTransport` 是 TCP-first 的公共路由层：`UNINITIALIZED/NEGOTIATING/FALLBACK_TCP` 都走 `TcpTransport`，仅当 `HandshakeSession` release 发布 `ESTABLISHED` 后才调用高速 Endpoint 的发送与等待钩子。成功升级后的 TCP 控制连接只允许 EOF，不再接受应用数据。
+`AdapterTransport` 是 TCP-first 的公共路由层：`UNINITIALIZED/NEGOTIATING/FALLBACK_TCP` 都走 `TcpTransport`，仅当 `HandshakeSession` release 发布 `ESTABLISHED` 后才调用高速 Endpoint 的发送与等待钩子。成功升级后的 TCP 控制连接只允许 EOF，不再接受应用数据。
 
 `HandshakeSession::RunClient/RunServer` 统一执行资源准备、Hello 收发、远端参数协商、ACK 收发以及 established/fallback/failed 发布。RDMA/UBSHM 仅通过 callback 提供 wire codec 和资源操作；RDMA server 的 `STEP_NEED_MORE` 仍由 bRPC 标准 parser 增量驱动，UBSHM server 使用同一驱动的 blocking 模式。
 
@@ -750,12 +762,13 @@ classDiagram
 
 | 项目 | 状态 | 说明 |
 |---|---|---|
-| TCP-first 路由 | 已实现 | RDMA/UBSHM 共同继承 `UpgradeTransport`，不再各自持有 `TcpTransport` |
+| TCP-first 路由 | 已实现 | RDMA/UBSHM 共同继承 `AdapterTransport`，不再各自持有 `TcpTransport` |
 | 公共握手处理 | 已实现 | `RunClient/RunServer` 统一 Hello、资源协商、ACK、fallback 和错误流程 |
-| RDMA client/server | 已迁移 | server 保留 #3350 的 bRPC 标准协议增量解析流程 |
+| RDMA client/server | 已迁移 | wire adapter、fallback server 和 v3 proto 已全部迁至 `src/brpc`；server 保留 #3350 的标准增量解析流程 |
 | UBSHM client/server | 已迁移公共驱动 | server 当前使用 blocking 模式；后续只需把输入方式迁移到标准 parser |
-| URMA | 待迁移 | origin/master 暂无受版本控制的 URMA Transport；合入后实现 `UpgradeTransport` 的数据面钩子并复用 `HandshakeSession` |
-| 通用 FrameCodec/Protocol adapter | 待实现 | 当前先复用 RDMA 已验证的 v2/v3 codec，避免一次改动 wire format 与 Transport 生命周期 |
+| URMA | 待迁移 | origin/master 暂无受版本控制的 URMA Transport；合入后实现 `AdapterTransport` 的数据面钩子并复用 `HandshakeSession` |
+| RDMA Protocol adapter | 已实现 | `RdmaHandshakeAdapter` 显式接收 enabled 状态，不再读取 Transport/Socket 私有状态 |
+| 通用 FrameCodec | 待实现 | 当前保留 RDMA 已验证的 v2/v3 framing，后续与 URMA/UBSHM 一起抽取 |
 
 ### 14.2 必须继承的修复语义
 
@@ -766,6 +779,7 @@ classDiagram
 | #3424 | 高速资源准备失败是可降级错误；清理部分资源并保持 TCP 可用 | RDMA 保留事务式 `AllocateResources`；失败后由公共 fallback 路径恢复 TCP |
 | #3425 | CQ re-arm 后同时补 poll send/recv CQ | 保留在 RDMA Endpoint 数据面，不移入握手组件 |
 | #3427 | 外部 Bazel workspace 下生成规则不能依赖主仓布局 | 公共实现不新增 proto；源码通过现有递归 glob 收录 |
+| server 同包 Hello/ACK | parser 只消费当前 Hello frame，不能清空后续 ACK/RPC；发送 Hello 后立即尝试解析已到达的 ACK | RDMA adapter 按声明长度消费扩展字段；`HandshakeSession::RunServer` 和 fallback parser 不强制等待下一次读事件 |
 
 ### 14.3 状态发布规则
 
diff --git a/src/brpc/upgrade_transport.cpp b/src/brpc/adapter_transport.cpp
similarity index 87%
rename from src/brpc/upgrade_transport.cpp
rename to src/brpc/adapter_transport.cpp
index e694b8f134..d9a245850c 100644
--- a/src/brpc/upgrade_transport.cpp
+++ b/src/brpc/adapter_transport.cpp
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include "brpc/upgrade_transport.h"
+#include "brpc/adapter_transport.h"
 
 #include <cstdint>
 #include <errno.h>
@@ -26,7 +26,7 @@
 
 namespace brpc {
 
-void UpgradeTransport::InitUpgradeTransport(
+void AdapterTransport::InitAdapterTransport(
     Socket* socket, const SocketOptions& options,
     const OnEdgeTrigger& default_on_edge) {
     _socket = socket;
@@ -40,11 +40,11 @@ void UpgradeTransport::InitUpgradeTransport(
     _tcp_transport->Init(socket, options);
 }
 
-void UpgradeTransport::ResetUpgradeTransport() {
+void AdapterTransport::ResetAdapterTransport() {
     _handshake.Reset(_socket);
 }
 
-int UpgradeTransport::CutFromIOBuf(butil::IOBuf* buf) {
+int AdapterTransport::CutFromIOBuf(butil::IOBuf* buf) {
     if (_handshake.phase() == handshake::ESTABLISHED) {
         butil::IOBuf* data[1] = {buf};
         return CutFromHighSpeedIOBufList(data, 1);
@@ -52,7 +52,7 @@ int UpgradeTransport::CutFromIOBuf(butil::IOBuf* buf) {
     return _tcp_transport->CutFromIOBuf(buf);
 }
 
-ssize_t UpgradeTransport::CutFromIOBufList(
+ssize_t AdapterTransport::CutFromIOBufList(
     butil::IOBuf** buf, size_t ndata) {
     if (_handshake.phase() == handshake::ESTABLISHED) {
         return CutFromHighSpeedIOBufList(buf, ndata);
@@ -60,7 +60,7 @@ ssize_t UpgradeTransport::CutFromIOBufList(
     return _tcp_transport->CutFromIOBufList(buf, ndata);
 }
 
-int UpgradeTransport::WaitEpollOut(butil::atomic<int>* epollout_butex,
+int AdapterTransport::WaitEpollOut(butil::atomic<int>* epollout_butex,
                                     bool pollin, timespec duetime) {
     if (_handshake.phase() == handshake::ESTABLISHED) {
         return WaitHighSpeedEpollOut(epollout_butex, pollin, duetime);
@@ -68,17 +68,17 @@ int UpgradeTransport::WaitEpollOut(butil::atomic<int>* epollout_butex,
     return _tcp_transport->WaitEpollOut(epollout_butex, pollin, duetime);
 }
 
-void UpgradeTransport::FallbackToTcp() {
+void AdapterTransport::FallbackToTcp() {
     _handshake.PublishFallback([this]() {
         SetHighSpeedAvailable(false);
     });
 }
 
-void UpgradeTransport::OnNewDataFromTcp(Socket* socket) {
-    static_cast<UpgradeTransport*>(socket->_transport.get())->ProcessTcpEvent();
+void AdapterTransport::OnNewDataFromTcp(Socket* socket) {
+    static_cast<AdapterTransport*>(socket->_transport.get())->ProcessTcpEvent();
 }
 
-void UpgradeTransport::ProcessTcpEvent() {
+void AdapterTransport::ProcessTcpEvent() {
     int progress = Socket::PROGRESS_INIT;
     while (true) {
         const int phase = _handshake.phase();
@@ -104,7 +104,7 @@ void UpgradeTransport::ProcessTcpEvent() {
     }
 }
 
-void UpgradeTransport::CheckUnexpectedTcpData() {
+void AdapterTransport::CheckUnexpectedTcpData() {
     int progress = Socket::PROGRESS_INIT;
     while (true) {
         uint8_t byte;
@@ -131,7 +131,7 @@ void UpgradeTransport::CheckUnexpectedTcpData() {
     }
 }
 
-void UpgradeTransport::TryReadOnTcp() {
+void AdapterTransport::TryReadOnTcp() {
     if (_socket->_nevent.fetch_add(1, butil::memory_order_acq_rel) != 0) {
         return;
     }
diff --git a/src/brpc/upgrade_transport.h b/src/brpc/adapter_transport.h
similarity index 88%
rename from src/brpc/upgrade_transport.h
rename to src/brpc/adapter_transport.h
index dba9c4b8a9..6819b9b079 100644
--- a/src/brpc/upgrade_transport.h
+++ b/src/brpc/adapter_transport.h
@@ -15,8 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#ifndef BRPC_UPGRADE_TRANSPORT_H
-#define BRPC_UPGRADE_TRANSPORT_H
+#ifndef BRPC_ADAPTER_TRANSPORT_H
+#define BRPC_ADAPTER_TRANSPORT_H
 
 #include <memory>
 
@@ -29,7 +29,7 @@ class TcpTransport;
 
 // A TCP-first transport that may switch its data plane after a successful
 // handshake. TCP remains usable before negotiation and after fallback.
-class UpgradeTransport : public Transport {
+class AdapterTransport : public Transport {
 public:
     int CutFromIOBuf(butil::IOBuf* buf) override;
     ssize_t CutFromIOBufList(butil::IOBuf** buf, size_t ndata) override;
@@ -42,12 +42,12 @@ class UpgradeTransport : public Transport {
     static void OnNewDataFromTcp(Socket* socket);
 
 protected:
-    UpgradeTransport() = default;
-    ~UpgradeTransport() override = default;
+    AdapterTransport() = default;
+    ~AdapterTransport() override = default;
 
-    void InitUpgradeTransport(Socket* socket, const SocketOptions& options,
+    void InitAdapterTransport(Socket* socket, const SocketOptions& options,
                               const OnEdgeTrigger& default_on_edge);
-    void ResetUpgradeTransport();
+    void ResetAdapterTransport();
 
     void FallbackToTcp();
     void TryReadOnTcp();
@@ -73,4 +73,4 @@ class UpgradeTransport : public Transport {
 
 }  // namespace brpc
 
-#endif  // BRPC_UPGRADE_TRANSPORT_H
+#endif  // BRPC_ADAPTER_TRANSPORT_H
diff --git a/src/brpc/input_messenger.h b/src/brpc/input_messenger.h
index f9d8881703..9c3f97fa8c 100644
--- a/src/brpc/input_messenger.h
+++ b/src/brpc/input_messenger.h
@@ -34,7 +34,7 @@ class UBShmEndpoint;
 }
 class TcpTransport;
 class RdmaTransport;
-class UpgradeTransport;
+class AdapterTransport;
 struct InputMessageHandler {
     // The callback to cut a message from `source'.
     // Returned message will be passed to process_request or process_response
@@ -98,7 +98,7 @@ class InputMessenger : public SocketUser {
 friend class Socket;
 friend class TcpTransport;
 friend class RdmaTransport;
-friend class UpgradeTransport;
+friend class AdapterTransport;
 friend class rdma::RdmaEndpoint;
 friend class ubring::UBShmEndpoint;
 public:
diff --git a/src/brpc/policy/rdma_handshake_protocol.cpp b/src/brpc/policy/rdma_handshake_protocol.cpp
index 580abdda5d..3a00610ad3 100644
--- a/src/brpc/policy/rdma_handshake_protocol.cpp
+++ b/src/brpc/policy/rdma_handshake_protocol.cpp
@@ -19,7 +19,7 @@
 
 #include "butil/logging.h"
 #include "brpc/destroyable.h"
-#include "brpc/rdma/rdma_handshake_server.h"
+#include "brpc/rdma_handshake_server.h"
 
 namespace brpc {
 namespace policy {
diff --git a/src/brpc/rdma/rdma_endpoint.cpp b/src/brpc/rdma/rdma_endpoint.cpp
index f8341d3e0b..c37402514f 100644
--- a/src/brpc/rdma/rdma_endpoint.cpp
+++ b/src/brpc/rdma/rdma_endpoint.cpp
@@ -31,8 +31,6 @@
 #include "brpc/rdma/rdma_helper.h"
 #include "brpc/rdma/rdma_endpoint.h"
 #include "brpc/rdma_transport.h"
-#include "brpc/rdma/rdma_handshake.h"
-#include "brpc/rdma/rdma_handshake_constants.h"
 
 DECLARE_int32(task_group_ntags);
 
@@ -53,8 +51,7 @@ extern int (*IbvQueryEce)(ibv_qp*, ibv_ece*);
 extern int (*IbvSetEce)(ibv_qp*, ibv_ece*);
 extern bool g_skip_rdma_init;
 
-// Only for UT: force AllocateResources() to fail, so that the "fallback to TCP" path
-// of the handshake can be tested without a real RDMA device.
+// Only for UT: force AllocateResources() to fail without a real RDMA device.
 bool g_fail_resource_alloc_for_test = false;
 
 DEFINE_int32(rdma_sq_size, 128, "SQ size for RDMA");
@@ -110,12 +107,7 @@ RdmaResource::~RdmaResource() {
 }
 
 RdmaEndpoint::RdmaEndpoint(Socket* s)
-#ifdef UNIT_TEST
-    : _state(s)
-    , _socket(s)
-#else
     : _socket(s)
-#endif
     , _resource(NULL)
     , _send_cq_events(0)
     , _recv_cq_events(0)
@@ -151,14 +143,6 @@ RdmaEndpoint::RdmaEndpoint(Socket* s)
     }
 }
 
-#ifdef UNIT_TEST
-RdmaEndpoint::StateView::operator State() const {
-    const RdmaTransport* transport =
-        static_cast<const RdmaTransport*>(_socket->_transport.get());
-    return static_cast<State>(transport->handshake_phase());
-}
-#endif
-
 RdmaEndpoint::~RdmaEndpoint() {
     Reset();
 }
@@ -190,7 +174,7 @@ void RdmaEndpoint::Reset() {
     _new_rq_wrs.store(0, butil::memory_order_relaxed);
 }
 
-void RdmaEndpoint::ApplyRemoteHello(const ParsedHello& remote) {
+void RdmaEndpoint::ApplyRemoteInfo(const RdmaConnectionInfo& remote) {
     _remote_recv_block_size = remote.block_size;
     _local_window_capacity = std::min(_sq_size, remote.rq_size) - RESERVED_WR_NUM;
     _remote_window_capacity = std::min(_rq_size, remote.sq_size) - RESERVED_WR_NUM;
@@ -199,24 +183,33 @@ void RdmaEndpoint::ApplyRemoteHello(const ParsedHello& remote) {
     _sq_window_size.store(_local_window_capacity, butil::memory_order_relaxed);
 }
 
-// Client-side handshake entry: the state machine.
-//
-//   C_ALLOC_QPCQ
-//     |
-//     v
-//   C_HELLO_SEND  (hs->SendLocalHello)
-//     |
-//     v
-//   C_HELLO_WAIT  (hs->ReceiveAndParseRemoteHello)
-//     |
-//     v
-//   [negotiation: ApplyRemoteHello + C_BRINGUP_QP]
-//     |
-//     v
-//   C_ACK_SEND
-//     |
-//     v
-//   ESTABLISHED / FALLBACK_TCP
+void RdmaEndpoint::GetLocalConnectionInfo(RdmaConnectionInfo* local) const {
+    CHECK(local != NULL);
+    local->block_size = g_rdma_recv_block_size;
+    local->sq_size = _sq_size;
+    local->rq_size = _rq_size;
+    local->lid = GetRdmaLid();
+    local->gid = GetRdmaGid();
+    local->qp_num = BAIDU_LIKELY(_resource)
+        ? _resource->qp->qp_num : 0;
+    local->ece.reset();
+    if (_outgoing_ece.has_value()) {
+        local->ece = _outgoing_ece;
+    }
+}
+
+int RdmaEndpoint::QueryLocalEce(ibv_ece* ece) const {
+    if (ece == NULL || IbvQueryEce == NULL ||
+        _resource == NULL || _resource->qp == NULL) {
+        return 1;
+    }
+    return IbvQueryEce(_resource->qp, ece) == 0 ? 0 : -1;
+}
+
+void RdmaEndpoint::SetOutgoingEce(const ibv_ece& ece) {
+    _outgoing_ece = ece;
+}
+
 bool RdmaEndpoint::IsWritable() const {
     if (BAIDU_UNLIKELY(g_skip_rdma_init)) {
         // Just for UT
@@ -735,7 +728,8 @@ int RdmaEndpoint::DoAllocateResources() {
     return 0;
 }
 
-int RdmaEndpoint::BringUpQp(const ParsedHello& remote, bool is_server) {
+int RdmaEndpoint::BringUpQp(
+    const RdmaConnectionInfo& remote, bool is_server) {
     if (BAIDU_UNLIKELY(g_skip_rdma_init)) {
         // For UT
         return 0;
@@ -763,7 +757,7 @@ int RdmaEndpoint::BringUpQp(const ParsedHello& remote, bool is_server) {
     // End-to-end model:
     //   Server: `remote->ece' is the client's queried ECE; set it here,
     //           then after RTS we query the reduced/negotiated ECE and
-    //           send it back in the server hello.
+    //           return it in the server negotiation response.
     //   Client: `remote->ece' is the server's reduced ECE;
     //           just set it here.
     bool use_ece = true;
@@ -832,7 +826,7 @@ int RdmaEndpoint::BringUpQp(const ParsedHello& remote, bool is_server) {
 
     // On the server side, now that the QP reached RTS, query the reduced/negotiated
     // ECE (the subset of enhancements supported by both peers) so it can be returned
-    // to the client in the server hello.
+    // to the client in the server negotiation response.
     if (is_server && use_ece && IbvQueryEce != NULL && remote.ece.has_value()) {
         ibv_ece ece;
         int qerr = IbvQueryEce(_resource->qp, &ece);
diff --git a/src/brpc/rdma/rdma_endpoint.h b/src/brpc/rdma/rdma_endpoint.h
index 9237c6fe1d..e3937c603a 100644
--- a/src/brpc/rdma/rdma_endpoint.h
+++ b/src/brpc/rdma/rdma_endpoint.h
@@ -31,7 +31,6 @@
 #include "butil/containers/mpsc_queue.h"
 #include "butil/containers/optional.h"
 #include "brpc/socket.h"
-#include "brpc/rdma/rdma_handshake_server.h"
 
 
 namespace brpc {
@@ -43,18 +42,17 @@ DECLARE_bool(rdma_use_polling);
 DECLARE_int32(rdma_poller_num);
 DECLARE_bool(rdma_disable_bthread);
 
-class RdmaHandshakeClientV2;
-class RdmaHandshakeServerV2;
-class RdmaHandshakeClientV3;
-class RdmaHandshakeServerV3;
-struct ParsedHello;
-enum class RemoteHelloResult;
-class RdmaHello;
-class RdmaEndpoint;
-
-namespace v3_wire {
-    void FillLocalRdmaHello(const RdmaEndpoint* ep, RdmaHello* msg);
-}  // namespace v3_wire
+// Wire-independent RDMA connection parameters consumed by resource setup.
+// Transport adapters translate their protocol-specific payload into this DTO.
+struct RdmaConnectionInfo {
+    uint32_t block_size;
+    uint16_t sq_size;
+    uint16_t rq_size;
+    uint16_t lid;
+    ibv_gid gid;
+    uint32_t qp_num;
+    butil::optional<ibv_ece> ece;
+};
 
 class RdmaConnect : public AppConnect {
 public:
@@ -90,44 +88,11 @@ struct RdmaResource {
 class BAIDU_CACHELINE_ALIGNMENT RdmaEndpoint : public SocketUser {
 friend class RdmaConnect;
 friend class Socket;
-friend class RdmaHandshakeClientV2;
-friend class RdmaHandshakeServerV2;
-friend class RdmaHandshakeClientV3;
-friend class RdmaHandshakeServerV3;
 friend class ::brpc::RdmaTransport;
-friend void v3_wire::FillLocalRdmaHello(const RdmaEndpoint*, RdmaHello*);
 public:
     explicit RdmaEndpoint(Socket* s);
     ~RdmaEndpoint() override;
 
-#ifdef UNIT_TEST
-    // Compatibility view for existing handshake tests. Production builds do
-    // not store handshake state in the endpoint; the value is read from the
-    // owning transport.
-    enum State {
-        UNINIT = 0x0,
-        C_ALLOC_QPCQ = 0x1,
-        C_HELLO_SEND = 0x2,
-        C_HELLO_WAIT = 0x3,
-        C_BRINGUP_QP = 0x4,
-        C_ACK_SEND = 0x5,
-        S_HELLO_WAIT = 0x11,
-        S_ALLOC_QPCQ = 0x12,
-        S_BRINGUP_QP = 0x13,
-        S_HELLO_SEND = 0x14,
-        S_ACK_WAIT = 0x15,
-        ESTABLISHED = 0x100,
-        FALLBACK_TCP = 0x200,
-        FAILED = 0x300
-    };
-    struct StateView {
-        explicit StateView(Socket* socket) : _socket(socket) {}
-        operator State() const;
-        Socket* _socket;
-    };
-    StateView _state;
-#endif
-
     // Global initialization
     // Return 0 if success, -1 if failed and errno set
     static int GlobalInitialize();
@@ -144,6 +109,12 @@ friend void v3_wire::FillLocalRdmaHello(const RdmaEndpoint*, RdmaHello*);
     // Whether the endpoint can send more data
     bool IsWritable() const;
 
+    // Resource information consumed by the transport-level RDMA adapter.
+    void GetLocalConnectionInfo(RdmaConnectionInfo* local) const;
+    // Returns 0 on success, 1 when ECE query is unavailable, -1 on error.
+    int QueryLocalEce(ibv_ece* ece) const;
+    void SetOutgoingEce(const ibv_ece& ece);
+
     // For debug
     void DebugInfo(std::ostream& os,
                    butil::StringPiece connector = "\n") const;
@@ -158,7 +129,7 @@ friend void v3_wire::FillLocalRdmaHello(const RdmaEndpoint*, RdmaHello*);
 
 private:
     // Allocate resources. On failure the endpoint is left with no RDMA
-    // resource attached, so that the handshake can safely fall back to TCP.
+    // resource attached, so the caller can safely continue without RDMA.
     // Return 0 if success, -1 if failed and errno set
     int AllocateResources();
 
@@ -208,18 +179,17 @@ friend void v3_wire::FillLocalRdmaHello(const RdmaEndpoint*, RdmaHello*);
     int DoPostRecv(void* block, size_t block_size);
 
     // Copy negotiated remote parameters into the endpoint and compute the
-    // SQ/RQ window capacities. Called by RdmaTransport after the peer's hello
-    // has been validated.
-    void ApplyRemoteHello(const ParsedHello& remote);
+    // SQ/RQ window capacities.
+    void ApplyRemoteInfo(const RdmaConnectionInfo& remote);
 
     // Bringup the QP from RESET state to RTS state.
     // Arguments:
-    //   remote: parsed remote hello. Provides the remote LID/GID/QP
+    //   remote: negotiated peer parameters. Provides the remote LID/GID/QP
     //           number for the RTR transition, and (on v3) the peer's
     //           ECE to set during the INIT->RTR transition.
     //   is_server: true on the server side, false on the client side.
     // Returns 0 on success, -1 on failed and errno set.
-    int BringUpQp(const ParsedHello& remote, bool is_server);
+    int BringUpQp(const RdmaConnectionInfo& remote, bool is_server);
 
     // Get event from comp channel and ack the events
     int GetAndAckEvents(SocketUniquePtr& s);
@@ -239,11 +209,7 @@ friend void v3_wire::FillLocalRdmaHello(const RdmaEndpoint*, RdmaHello*);
     // Not owner
     Socket* _socket;
 
-    // ECE payload to advertise in the next local hello:
-    //   Client: the locally queried ECE capabilities (filled
-    //           before C_HELLO_SEND);
-    //   Server: the reduced/negotiated ECE queried after the
-    //           QP reached RTS (filled in BringUpQp).
+    // ECE payload prepared by resource setup and consumed by the RDMA adapter.
     butil::optional<ibv_ece> _outgoing_ece;
 
     // rdma resource
diff --git a/src/brpc/rdma/rdma_handshake.cpp b/src/brpc/rdma_handshake.cpp
similarity index 79%
rename from src/brpc/rdma/rdma_handshake.cpp
rename to src/brpc/rdma_handshake.cpp
index 8e7616e0aa..2e7edd2fa5 100644
--- a/src/brpc/rdma/rdma_handshake.cpp
+++ b/src/brpc/rdma_handshake.cpp
@@ -17,8 +17,8 @@
 
 #if BRPC_WITH_RDMA
 
-#include "brpc/rdma/rdma_handshake.h"
-#include "brpc/rdma/rdma_handshake_constants.h"
+#include "brpc/rdma_handshake.h"
+#include "brpc/rdma_handshake_constants.h"
 
 #include <string.h>
 #include <algorithm>            // std::min
@@ -30,10 +30,7 @@
 #include "butil/raw_pack.h"      // RawPacker, RawUnpacker
 #include "brpc/socket.h"
 #include "brpc/rdma/rdma_endpoint.h"
-#include "brpc/rdma/rdma_helper.h"
-#include "brpc/rdma_transport.h"
-#include "brpc/rdma/rdma_handshake.pb.h"
-#include "butil/object_pool.h"
+#include "brpc/rdma_handshake.pb.h"
 
 namespace brpc {
 namespace rdma {
@@ -47,17 +44,30 @@ DECLARE_bool(rdma_trace_verbose);
 
 extern const uint16_t MIN_QP_SIZE;
 extern const uint16_t MIN_BLOCK_SIZE;
-extern uint32_t g_rdma_recv_block_size;
 extern bool g_skip_rdma_init;
 
-extern int (*IbvQueryEce)(ibv_qp*, ibv_ece*);
-
 DEFINE_bool(rdma_ece, false, "Enable end-to-end ECE (Enhanced Connection Establishment) "
                              "negotiation in the RDMA v3 handshake. Automatically degrades "
                              "to no-ECE when the peer, the local libibverbs, or set_ece "
                              "does not support it. Acts as a kill switch (default off).");
 
-DECLARE_bool(rdma_trace_verbose);
+void RdmaHandshakeAdapter::FillLocalHello(ParsedHello* local) const {
+    _ep->GetLocalConnectionInfo(local);
+}
+
+void RdmaHandshakeAdapter::PrepareClientEce() {
+    if (!FLAGS_rdma_ece) {
+        return;
+    }
+    ibv_ece ece;
+    const int rc = _ep->QueryLocalEce(&ece);
+    if (rc == 0) {
+        _ep->SetOutgoingEce(ece);
+    } else if (rc < 0) {
+        LOG_IF(WARNING, FLAGS_rdma_trace_verbose)
+            << "Fail to IbvQueryEce on client, ECE not advertised";
+    }
+}
 
 namespace v2_wire {
 
@@ -152,31 +162,30 @@ int DrainBytes(handshake::SocketHandshakeIO* io, size_t n) {
 
 }  // namespace v2_wire
 
-int RdmaHandshakeClientV2::SendLocalHello() {
-    RdmaEndpoint* ep = _ep;
+int RdmaClientHandshakeAdapterV2::SendLocalHello(bool enabled) {
+    CHECK(enabled);
     uint8_t data[HELLO_V2_MSG_LEN_MIN];
+    ParsedHello local{};
+    FillLocalHello(&local);
 
     v2_wire::HelloMessage local_msg{};
     local_msg.msg_len = HELLO_V2_MSG_LEN_MIN;
     local_msg.hello_ver = HELLO_V2_VERSION;
     local_msg.impl_ver = IMPL_V2_VERSION;
-    local_msg.block_size = g_rdma_recv_block_size;
-    local_msg.sq_size = ep->_sq_size;
-    local_msg.rq_size = ep->_rq_size;
-    local_msg.lid = GetRdmaLid();
-    local_msg.gid = GetRdmaGid();
-    if (BAIDU_LIKELY(ep->_resource)) {
-        local_msg.qp_num = ep->_resource->qp->qp_num;
-    } else {
-        // Only happens in UT
-        local_msg.qp_num = 0;
-    }
+    local_msg.block_size = local.block_size;
+    local_msg.sq_size = local.sq_size;
+    local_msg.rq_size = local.rq_size;
+    local_msg.lid = local.lid;
+    local_msg.gid = local.gid;
+    local_msg.qp_num = local.qp_num;
     fast_memcpy(data, HELLO_MAGIC, 4);
     local_msg.Serialize((char*)data + 4);
     return _io->WriteAll(data, HELLO_V2_MSG_LEN_MIN);
 }
 
-RemoteHelloResult RdmaHandshakeClientV2::ReceiveAndParseRemoteHello(ParsedHello* remote) {
+RemoteHelloResult
+RdmaClientHandshakeAdapterV2::ReceiveAndParseRemoteHello(
+    ParsedHello* remote) {
     uint8_t magic[HELLO_MAGIC_LEN];
     if (_io->ReadExact(magic, HELLO_MAGIC_LEN) < 0) {
         return RemoteHelloResult::ERROR;
@@ -191,7 +200,9 @@ RemoteHelloResult RdmaHandshakeClientV2::ReceiveAndParseRemoteHello(ParsedHello*
 
 // Parse one complete v2 client hello out of `_source` (non-blocking).
 // v2 hello: [ "RDMA" 4B ][ msg_len 2B ][ 34B ... ], base total = 40B.
-RemoteHelloResult RdmaHandshakeServerV2::ReceiveAndParseRemoteHello(ParsedHello* remote) {
+RemoteHelloResult
+RdmaServerHandshakeAdapterV2::ReceiveAndParseRemoteHello(
+    ParsedHello* remote) {
     butil::IOBuf* source = _source;
     constexpr size_t HDR_LEN = HELLO_MAGIC_LEN + 2;
     if (source->size() < HDR_LEN) {
@@ -217,9 +228,11 @@ RemoteHelloResult RdmaHandshakeServerV2::ReceiveAndParseRemoteHello(ParsedHello*
     CHECK_EQ(source->pop_front(HELLO_MAGIC_LEN), HELLO_MAGIC_LEN);
     uint8_t body[HELLO_V2_MSG_LEN_MIN - HELLO_MAGIC_LEN];  // 36B
     CHECK_EQ(source->cutn(body, sizeof(body)), sizeof(body));
-    if (!source->empty()) {
-        // Drain unknown trailing bytes.
-        source->clear();
+    const size_t extension_len = msg_len - HELLO_V2_MSG_LEN_MIN;
+    if (extension_len != 0) {
+        // Consume only this frame's optional extension. A coalesced ACK or RPC
+        // belongs to the next parser stage and must remain in source.
+        CHECK_EQ(source->pop_front(extension_len), extension_len);
     }
 
     v2_wire::HelloMessage remote_msg{};
@@ -231,12 +244,11 @@ RemoteHelloResult RdmaHandshakeServerV2::ReceiveAndParseRemoteHello(ParsedHello*
     return RemoteHelloResult::NEGOTIATED;
 }
 
-int RdmaHandshakeServerV2::SendLocalHello() {
+int RdmaServerHandshakeAdapterV2::SendLocalHello(bool enabled) {
     uint8_t data[HELLO_V2_MSG_LEN_MIN];
     v2_wire::HelloMessage local_msg{};
     local_msg.msg_len = HELLO_V2_MSG_LEN_MIN;
-    auto rdma_transport = static_cast<RdmaTransport*>(_ep->_socket->_transport.get());
-    if (rdma_transport->_rdma_state == RdmaTransport::RDMA_OFF) {
+    if (!enabled) {
         local_msg.hello_ver = 0;
         local_msg.impl_ver = 0;
         local_msg.block_size = 0;
@@ -246,19 +258,16 @@ int RdmaHandshakeServerV2::SendLocalHello() {
         memset(local_msg.gid.raw, 0, sizeof(local_msg.gid.raw));
         local_msg.qp_num     = 0;
     } else {
+        ParsedHello local{};
+        FillLocalHello(&local);
         local_msg.hello_ver = HELLO_V2_VERSION;
         local_msg.impl_ver = IMPL_V2_VERSION;
-        local_msg.block_size = g_rdma_recv_block_size;
-        local_msg.sq_size = _ep->_sq_size;
-        local_msg.rq_size = _ep->_rq_size;
-        local_msg.lid = GetRdmaLid();
-        local_msg.gid = GetRdmaGid();
-        if (BAIDU_LIKELY(_ep->_resource)) {
-            local_msg.qp_num = _ep->_resource->qp->qp_num;
-        } else {
-            // Only happens in UT
-            local_msg.qp_num = 0;
-        }
+        local_msg.block_size = local.block_size;
+        local_msg.sq_size = local.sq_size;
+        local_msg.rq_size = local.rq_size;
+        local_msg.lid = local.lid;
+        local_msg.gid = local.gid;
+        local_msg.qp_num = local.qp_num;
     }
     fast_memcpy(data, HELLO_MAGIC, 4);
     local_msg.Serialize((char*)data + 4);
@@ -292,19 +301,14 @@ bool ValidRdmaHello(const RdmaHello& msg) {
     return true;
 }
 
-void FillLocalRdmaHello(const RdmaEndpoint* ep, RdmaHello* msg) {
-    msg->set_block_size(g_rdma_recv_block_size);
-    msg->set_sq_size(ep->_sq_size);
-    msg->set_rq_size(ep->_rq_size);
-    msg->set_lid(GetRdmaLid());
-    ibv_gid gid = GetRdmaGid();
-    msg->set_gid(reinterpret_cast<const char*>(gid.raw), sizeof(gid.raw));
-    if (BAIDU_LIKELY(ep->_resource)) {
-        msg->set_qp_num(ep->_resource->qp->qp_num);
-    } else {
-        // Only happens in UT
-        msg->set_qp_num(0);
-    }
+void FillLocalRdmaHello(const ParsedHello& local, RdmaHello* msg) {
+    msg->set_block_size(local.block_size);
+    msg->set_sq_size(local.sq_size);
+    msg->set_rq_size(local.rq_size);
+    msg->set_lid(local.lid);
+    msg->set_gid(reinterpret_cast<const char*>(local.gid.raw),
+                 sizeof(local.gid.raw));
+    msg->set_qp_num(local.qp_num);
 
     // Advertise ECE only when enabled. Role-dependent payload:
     //   Client hello: the locally queried ECE capabilities;
@@ -315,11 +319,11 @@ void FillLocalRdmaHello(const RdmaEndpoint* ep, RdmaHello* msg) {
     // _outgoing_ece in a role-specific way: client side stores its locally
     // queried capabilities; server side stores the reduced/negotiated ECE
     // after RTS. nullopt -> omit the field (peer degrades to no-ECE).
-    if (FLAGS_rdma_ece && ep->_outgoing_ece.has_value()) {
+    if (FLAGS_rdma_ece && local.ece.has_value()) {
         RdmaEce* ece = msg->mutable_ece();
-        ece->set_vendor_id(ep->_outgoing_ece->vendor_id);
-        ece->set_options(ep->_outgoing_ece->options);
-        ece->set_comp_mask(ep->_outgoing_ece->comp_mask);
+        ece->set_vendor_id(local.ece->vendor_id);
+        ece->set_options(local.ece->options);
+        ece->set_comp_mask(local.ece->comp_mask);
     }
 }
 
@@ -387,28 +391,23 @@ void TranslateHello(const RdmaHello& msg, ParsedHello* out) {
 
 }  // namespace v3_wire
 
-int RdmaHandshakeClientV3::SendLocalHello() {
+int RdmaClientHandshakeAdapterV3::SendLocalHello(bool enabled) {
+    CHECK(enabled);
     // Query local ECE capabilities so they can be advertised in the client
     // hello. v3-only. Best-effort: any failure or missing API just means we
     // won't advertise ECE (the peer then degrades to no-ECE establishment).
-    if (FLAGS_rdma_ece && IbvQueryEce != NULL &&
-        _ep->_resource && _ep->_resource->qp) {
-        ibv_ece ece;
-        if (IbvQueryEce(_ep->_resource->qp, &ece) == 0) {
-            _ep->_outgoing_ece = ece;
-        } else {
-            LOG_IF(WARNING, FLAGS_rdma_trace_verbose)
-                << "Fail to IbvQueryEce on client, ECE not advertised: "
-                << _ep->_socket->description();
-        }
-    }
+    PrepareClientEce();
 
+    ParsedHello local{};
+    FillLocalHello(&local);
     RdmaHello local_msg{};
-    v3_wire::FillLocalRdmaHello(_ep, &local_msg);
+    v3_wire::FillLocalRdmaHello(local, &local_msg);
     return v3_wire::WriteV3Hello(_io, local_msg);
 }
 
-RemoteHelloResult RdmaHandshakeClientV3::ReceiveAndParseRemoteHello(ParsedHello* remote) {
+RemoteHelloResult
+RdmaClientHandshakeAdapterV3::ReceiveAndParseRemoteHello(
+    ParsedHello* remote) {
     uint8_t magic[HELLO_MAGIC_LEN];
     if (_io->ReadExact(magic, HELLO_MAGIC_LEN) < 0) {
         return RemoteHelloResult::ERROR;
@@ -431,7 +430,9 @@ RemoteHelloResult RdmaHandshakeClientV3::ReceiveAndParseRemoteHello(ParsedHello*
 
 // Parse one complete v3 client hello out of `_source` (non-blocking).
 // v3 hello: [ "RDM3" 4B ][ pb_size 4B (big-endian) ][ RdmaHello ]
-RemoteHelloResult RdmaHandshakeServerV3::ReceiveAndParseRemoteHello(ParsedHello* remote) {
+RemoteHelloResult
+RdmaServerHandshakeAdapterV3::ReceiveAndParseRemoteHello(
+    ParsedHello* remote) {
     constexpr size_t HDR_LEN = HELLO_MAGIC_LEN + HELLO_V3_PB_SIZE_LEN;
     if (_source->size() < HDR_LEN) {
         // pb_size has not fully arrived yet.
@@ -470,10 +471,9 @@ RemoteHelloResult RdmaHandshakeServerV3::ReceiveAndParseRemoteHello(ParsedHello*
     return RemoteHelloResult::NEGOTIATED;
 }
 
-int RdmaHandshakeServerV3::SendLocalHello() {
+int RdmaServerHandshakeAdapterV3::SendLocalHello(bool enabled) {
     RdmaHello local_msg{};
-    auto rdma_transport = static_cast<RdmaTransport*>(_ep->_socket->_transport.get());
-    if (rdma_transport->_rdma_state == RdmaTransport::RDMA_OFF) {
+    if (!enabled) {
         // Un-negotiable hello: all body fields are zero so the client's
         // rejects it and downgrades to TCP on the same connection.
         local_msg.set_block_size(0);
@@ -483,32 +483,36 @@ int RdmaHandshakeServerV3::SendLocalHello() {
         local_msg.set_gid(std::string(sizeof(ibv_gid), '\0'));
         local_msg.set_qp_num(0);
     } else {
-        v3_wire::FillLocalRdmaHello(_ep, &local_msg);
+        ParsedHello local{};
+        FillLocalHello(&local);
+        v3_wire::FillLocalRdmaHello(local, &local_msg);
     }
     return v3_wire::WriteV3Hello(_io, local_msg);
 }
 
-std::unique_ptr<RdmaHandshake> CreateClientHandshake(
+std::unique_ptr<RdmaHandshakeAdapter> CreateClientHandshakeAdapter(
     RdmaEndpoint* ep, handshake::SocketHandshakeIO* io) {
     switch (FLAGS_rdma_client_handshake_version) {
     case 3:
-        return std::unique_ptr<RdmaHandshake>(new RdmaHandshakeClientV3(ep, io));
+        return std::unique_ptr<RdmaHandshakeAdapter>(
+            new RdmaClientHandshakeAdapterV3(ep, io));
     case 2:
     default:
-        return std::unique_ptr<RdmaHandshake>(new RdmaHandshakeClientV2(ep, io));
+        return std::unique_ptr<RdmaHandshakeAdapter>(
+            new RdmaClientHandshakeAdapterV2(ep, io));
     }
 }
 
-std::unique_ptr<RdmaHandshake> CreateServerHandshakeByMagic(
+std::unique_ptr<RdmaHandshakeAdapter> CreateServerHandshakeAdapterByMagic(
     RdmaEndpoint* ep, handshake::SocketHandshakeIO* io, butil::IOBuf* source,
     const uint8_t magic[HELLO_MAGIC_LEN]) {
     if (memcmp(magic, HELLO_MAGIC, HELLO_MAGIC_LEN) == 0) {
-        return std::unique_ptr<RdmaHandshake>(
-                new RdmaHandshakeServerV2(ep, io, source));
+        return std::unique_ptr<RdmaHandshakeAdapter>(
+            new RdmaServerHandshakeAdapterV2(ep, io, source));
     }
     if (memcmp(magic, HELLO_MAGIC_V3, HELLO_MAGIC_LEN) == 0) {
-        return std::unique_ptr<RdmaHandshake>(
-                new RdmaHandshakeServerV3(ep, io, source));
+        return std::unique_ptr<RdmaHandshakeAdapter>(
+            new RdmaServerHandshakeAdapterV3(ep, io, source));
     }
     return NULL;
 }
diff --git a/src/brpc/rdma/rdma_handshake.h b/src/brpc/rdma_handshake.h
similarity index 64%
rename from src/brpc/rdma/rdma_handshake.h
rename to src/brpc/rdma_handshake.h
index 3befe815ab..cb048cf046 100644
--- a/src/brpc/rdma/rdma_handshake.h
+++ b/src/brpc/rdma_handshake.h
@@ -24,7 +24,8 @@
 #include <infiniband/verbs.h>
 #include "butil/macros.h"
 #include "butil/containers/optional.h"
-#include "brpc/rdma/rdma_handshake_constants.h"
+#include "brpc/rdma/rdma_endpoint.h"
+#include "brpc/rdma_handshake_constants.h"
 #include "brpc/transport_handshake.h"
 
 namespace butil {
@@ -34,26 +35,11 @@ class IOBuf;
 namespace brpc {
 namespace rdma {
 
-class RdmaEndpoint;
-
 // Wire-format-agnostic representation of a peer's hello message.
 // Each protocol version (v2 binary, v3 protobuf) translates its own
 // wire format into this struct so the state-machine driver in RdmaTransport
 // stays free of any wire-format details.
-struct ParsedHello {
-    uint32_t block_size;
-    uint16_t sq_size;
-    uint16_t rq_size;
-    uint16_t lid;
-    ibv_gid  gid;
-    uint32_t qp_num;
-    // ECE (Enhanced Connection Establishment), v3 handshake only.
-    // nullopt means the peer did not advertise any ECE (either it disabled
-    // ECE, its lib does not support ECE, or it is a v2 peer). When engaged:
-    //   - on the server side: the client's queried ECE capabilities;
-    //   - on the client side: the server's reduced/negotiated ECE.
-    butil::optional<ibv_ece> ece;
-};
+using ParsedHello = RdmaConnectionInfo;
 
 // Result of reading/parsing a peer's hello (see ReceiveAndParseRemoteHello).
 enum class RemoteHelloResult {
@@ -88,13 +74,14 @@ struct HelloMessage {
 }  // namespace v2_wire
 
 // Base class of an RDMA handshake, shared by both roles.
-class RdmaHandshake {
+class RdmaHandshakeAdapter {
 public:
-    RdmaHandshake(RdmaEndpoint* ep, handshake::SocketHandshakeIO* io, int version)
+    RdmaHandshakeAdapter(
+        RdmaEndpoint* ep, handshake::SocketHandshakeIO* io, int version)
         : _ep(ep), _io(io), _version(version) {}
-    virtual ~RdmaHandshake() = default;
+    virtual ~RdmaHandshakeAdapter() = default;
 
-    DISALLOW_COPY_AND_ASSIGN(RdmaHandshake);
+    DISALLOW_COPY_AND_ASSIGN(RdmaHandshakeAdapter);
 
     // Wire-level protocol version (2 for "RDMA", 3 for "RDM3").
     int ProtocolVersion() const { return _version; }
@@ -108,12 +95,19 @@ class RdmaHandshake {
     //   - v2: zero hello_ver/impl_ver so the peer's HelloNegotiationValid
     //         rejects it;
     //   - v3: qp_num==0 so the peer's ValidRdmaHello rejects it.
-    virtual int SendLocalHello() = 0;
+    virtual int SendLocalHello(bool enabled) = 0;
 
     // Read and parse the peer's hello into *remote.
     virtual RemoteHelloResult ReceiveAndParseRemoteHello(ParsedHello* remote) = 0;
 
 protected:
+    // Translate the endpoint's local resource state into the wire-independent
+    // adapter representation. Endpoint internals never leak into the codec.
+    void FillLocalHello(ParsedHello* local) const;
+
+    // Best-effort v3 client ECE preparation. Failure only disables ECE.
+    void PrepareClientEce();
+
     RdmaEndpoint* _ep;
     handshake::SocketHandshakeIO* _io;
     int _version;
@@ -121,50 +115,55 @@ class RdmaHandshake {
 
 // Server-side handshake base: parses the remote hello non-blockingly out of
 // `_source` (an IOBuf filled by InputMessenger), never touching the fd.
-class ServerRdmaHandshake : public RdmaHandshake {
+class RdmaServerHandshakeAdapter : public RdmaHandshakeAdapter {
 public:
-    ServerRdmaHandshake(RdmaEndpoint* ep, handshake::SocketHandshakeIO* io,
-                        butil::IOBuf* source, int version)
-        : RdmaHandshake(ep, io, version), _source(source) {}
+    RdmaServerHandshakeAdapter(
+        RdmaEndpoint* ep, handshake::SocketHandshakeIO* io,
+        butil::IOBuf* source, int version)
+        : RdmaHandshakeAdapter(ep, io, version), _source(source) {}
 
 protected:
     butil::IOBuf* _source;
 };
 
 // v2 handshake (legacy "RDMA" magic, 36B binary HelloMessage).
-class RdmaHandshakeClientV2 : public RdmaHandshake {
+class RdmaClientHandshakeAdapterV2 : public RdmaHandshakeAdapter {
 public:
-    RdmaHandshakeClientV2(RdmaEndpoint* ep, handshake::SocketHandshakeIO* io)
-        : RdmaHandshake(ep, io, 2) {}
-    int SendLocalHello() override;
+    RdmaClientHandshakeAdapterV2(
+        RdmaEndpoint* ep, handshake::SocketHandshakeIO* io)
+        : RdmaHandshakeAdapter(ep, io, 2) {}
+    int SendLocalHello(bool enabled) override;
     RemoteHelloResult ReceiveAndParseRemoteHello(ParsedHello* remote) override;
 };
 
-class RdmaHandshakeServerV2 : public ServerRdmaHandshake {
+class RdmaServerHandshakeAdapterV2 : public RdmaServerHandshakeAdapter {
 public:
-    RdmaHandshakeServerV2(RdmaEndpoint* ep, handshake::SocketHandshakeIO* io,
-                          butil::IOBuf* source)
-        : ServerRdmaHandshake(ep, io, source, 2) {}
-    int SendLocalHello() override;
+    RdmaServerHandshakeAdapterV2(
+        RdmaEndpoint* ep, handshake::SocketHandshakeIO* io,
+        butil::IOBuf* source)
+        : RdmaServerHandshakeAdapter(ep, io, source, 2) {}
+    int SendLocalHello(bool enabled) override;
     RemoteHelloResult ReceiveAndParseRemoteHello(ParsedHello* remote) override;
 };
 
 // v3 handshake (new "RDM3" magic, protobuf RdmaHello).
 // [ "RDM3" 4B ][ pb_size 4B (big-endian) ][ RdmaHello protobuf bytes ]
-class RdmaHandshakeClientV3 : public RdmaHandshake {
+class RdmaClientHandshakeAdapterV3 : public RdmaHandshakeAdapter {
 public:
-    RdmaHandshakeClientV3(RdmaEndpoint* ep, handshake::SocketHandshakeIO* io)
-        : RdmaHandshake(ep, io, 3) {}
-    int SendLocalHello() override;
+    RdmaClientHandshakeAdapterV3(
+        RdmaEndpoint* ep, handshake::SocketHandshakeIO* io)
+        : RdmaHandshakeAdapter(ep, io, 3) {}
+    int SendLocalHello(bool enabled) override;
     RemoteHelloResult ReceiveAndParseRemoteHello(ParsedHello* remote) override;
 };
 
-class RdmaHandshakeServerV3 : public ServerRdmaHandshake {
+class RdmaServerHandshakeAdapterV3 : public RdmaServerHandshakeAdapter {
 public:
-    RdmaHandshakeServerV3(RdmaEndpoint* ep, handshake::SocketHandshakeIO* io,
-                          butil::IOBuf* source)
-        : ServerRdmaHandshake(ep, io, source, 3) {}
-    int SendLocalHello() override;
+    RdmaServerHandshakeAdapterV3(
+        RdmaEndpoint* ep, handshake::SocketHandshakeIO* io,
+        butil::IOBuf* source)
+        : RdmaServerHandshakeAdapter(ep, io, source, 3) {}
+    int SendLocalHello(bool enabled) override;
     RemoteHelloResult ReceiveAndParseRemoteHello(ParsedHello* remote) override;
 };
 
@@ -172,18 +171,18 @@ class RdmaHandshakeServerV3 : public ServerRdmaHandshake {
 //
 // Pick the client-side handshake based on
 // FLAGS_rdma_client_handshake_version:
-//   2 (default) -> RdmaHandshakeClientV2
-//   3           -> RdmaHandshakeClientV3
+//   2 (default) -> RdmaClientHandshakeAdapterV2
+//   3           -> RdmaClientHandshakeAdapterV3
 // Other values fall back to V2.
-std::unique_ptr<RdmaHandshake> CreateClientHandshake(
+std::unique_ptr<RdmaHandshakeAdapter> CreateClientHandshakeAdapter(
     RdmaEndpoint* ep, handshake::SocketHandshakeIO* io);
 
 // Pick the server-side handshake based on the 4B magic already read.
 // Returns NULL if `magic` is not a recognized RDMA magic
 // (the caller should then fallback to TCP).
-//   "RDMA" -> RdmaHandshakeServerV2
-//   "RDM3" -> RdmaHandshakeServerV3
-std::unique_ptr<RdmaHandshake> CreateServerHandshakeByMagic(
+//   "RDMA" -> RdmaServerHandshakeAdapterV2
+//   "RDM3" -> RdmaServerHandshakeAdapterV3
+std::unique_ptr<RdmaHandshakeAdapter> CreateServerHandshakeAdapterByMagic(
     RdmaEndpoint* ep, handshake::SocketHandshakeIO* io, butil::IOBuf* source,
     const uint8_t magic[HELLO_MAGIC_LEN]);
 
diff --git a/src/brpc/rdma/rdma_handshake.proto b/src/brpc/rdma_handshake.proto
similarity index 100%
rename from src/brpc/rdma/rdma_handshake.proto
rename to src/brpc/rdma_handshake.proto
diff --git a/src/brpc/rdma/rdma_handshake_constants.h b/src/brpc/rdma_handshake_constants.h
similarity index 94%
rename from src/brpc/rdma/rdma_handshake_constants.h
rename to src/brpc/rdma_handshake_constants.h
index aa9811b98e..c60c70f170 100644
--- a/src/brpc/rdma/rdma_handshake_constants.h
+++ b/src/brpc/rdma_handshake_constants.h
@@ -15,8 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#ifndef BRPC_RDMA_RDMA_HANDSHAKE_CONSTANTS_H
-#define BRPC_RDMA_RDMA_HANDSHAKE_CONSTANTS_H
+#ifndef BRPC_RDMA_HANDSHAKE_CONSTANTS_H
+#define BRPC_RDMA_HANDSHAKE_CONSTANTS_H
 
 namespace brpc {
 namespace rdma {
@@ -53,4 +53,4 @@ constexpr uint32_t HELLO_ACK_RDMA_OK = 0x1;
 }  // namespace rdma
 }  // namespace brpc
 
-#endif  // BRPC_RDMA_RDMA_HANDSHAKE_CONSTANTS_H
+#endif  // BRPC_RDMA_HANDSHAKE_CONSTANTS_H
diff --git a/src/brpc/rdma/rdma_handshake_server.cpp b/src/brpc/rdma_handshake_server.cpp
similarity index 96%
rename from src/brpc/rdma/rdma_handshake_server.cpp
rename to src/brpc/rdma_handshake_server.cpp
index d52532dec2..68404ae28f 100644
--- a/src/brpc/rdma/rdma_handshake_server.cpp
+++ b/src/brpc/rdma_handshake_server.cpp
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include "brpc/rdma/rdma_handshake_server.h"
+#include "brpc/rdma_handshake_server.h"
 
 #include <limits>
 #include <string>
@@ -25,8 +25,8 @@
 #include "butil/raw_pack.h"
 #include "butil/sys_byteorder.h"
 #include "brpc/socket.h"
-#include "brpc/rdma/rdma_handshake.pb.h"
-#include "brpc/rdma/rdma_handshake_constants.h"
+#include "brpc/rdma_handshake.pb.h"
+#include "brpc/rdma_handshake_constants.h"
 #if BRPC_WITH_RDMA
 #include "brpc/rdma_transport.h"
 #endif
@@ -173,9 +173,9 @@ static ParseResult FallbackServerHandshake(butil::IOBuf* source, Socket* socket)
         if (SendUnnegotiableHello(socket, version) < 0) {
             return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
         }
-        // Wait for the client ACK across subsequent reads.
+        // Keep the phase across subsequent reads, then immediately try the
+        // ACK path below in case Hello and ACK arrived in one TCP packet.
         socket->reset_parsing_context(ServerHandshakeContext::Create());
-        return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
     }
 
     // Phase 2: drain the 4B ACK.
diff --git a/src/brpc/rdma/rdma_handshake_server.h b/src/brpc/rdma_handshake_server.h
similarity index 92%
rename from src/brpc/rdma/rdma_handshake_server.h
rename to src/brpc/rdma_handshake_server.h
index a91b625a1a..c4c5c91343 100644
--- a/src/brpc/rdma/rdma_handshake_server.h
+++ b/src/brpc/rdma_handshake_server.h
@@ -15,8 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#ifndef BRPC_RDMA_RDMA_HANDSHAKE_SERVER_H
-#define BRPC_RDMA_RDMA_HANDSHAKE_SERVER_H
+#ifndef BRPC_RDMA_HANDSHAKE_SERVER_H
+#define BRPC_RDMA_HANDSHAKE_SERVER_H
 
 #include "brpc/parse_result.h"
 #include "brpc/transport_handshake.h"
@@ -41,4 +41,4 @@ ParseResult ExecuteServerHandshake(butil::IOBuf* source, Socket* socket);
 }  // namespace rdma
 }  // namespace brpc
 
-#endif  // BRPC_RDMA_RDMA_HANDSHAKE_SERVER_H
+#endif  // BRPC_RDMA_HANDSHAKE_SERVER_H
diff --git a/src/brpc/rdma_transport.cpp b/src/brpc/rdma_transport.cpp
index 1af007a8b0..ff8ba3e43e 100644
--- a/src/brpc/rdma_transport.cpp
+++ b/src/brpc/rdma_transport.cpp
@@ -22,9 +22,9 @@
 #include "brpc/event_dispatcher.h"
 #include "brpc/input_messenger.h"
 #include "brpc/rdma/rdma_endpoint.h"
-#include "brpc/rdma/rdma_handshake.h"
-#include "brpc/rdma/rdma_handshake_constants.h"
-#include "brpc/rdma/rdma_handshake_server.h"
+#include "brpc/rdma_handshake.h"
+#include "brpc/rdma_handshake_constants.h"
+#include "brpc/rdma_handshake_server.h"
 #include "brpc/rdma/rdma_helper.h"
 
 namespace brpc {
@@ -85,8 +85,9 @@ void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
     LOG_IF(INFO, rdma::FLAGS_rdma_trace_verbose)
         << "Start handshake on " << socket->description();
 
-    std::unique_ptr<rdma::RdmaHandshake> protocol =
-        rdma::CreateClientHandshake(ep, transport->_handshake.io());
+    std::unique_ptr<rdma::RdmaHandshakeAdapter> protocol =
+        rdma::CreateClientHandshakeAdapter(
+            ep, transport->_handshake.io());
     CHECK(protocol != NULL);
     transport->_handshake.set_protocol_version(protocol->ProtocolVersion());
     rdma::ParsedHello remote{};
@@ -107,7 +108,7 @@ void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
         return handshake::STEP_FALLBACK;
     };
     callbacks.send_local_hello = [&]() {
-        if (protocol->SendLocalHello() == 0) {
+        if (protocol->SendLocalHello(true) == 0) {
             return handshake::STEP_OK;
         }
         const int saved_errno = errno;
@@ -132,7 +133,7 @@ void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
         return handshake::STEP_ERROR;
     };
     callbacks.negotiate_resources = [&]() {
-        ep->ApplyRemoteHello(remote);
+        ep->ApplyRemoteInfo(remote);
         if (ep->BringUpQp(remote, false) == 0) {
             return handshake::STEP_OK;
         }
@@ -183,13 +184,12 @@ ParseResult RdmaTransport::ExecuteServerHandshake(butil::IOBuf* source,
     rdma::RdmaEndpoint* ep = transport->_rdma_ep;
     CHECK(ep != NULL);
 
-    std::unique_ptr<rdma::RdmaHandshake> protocol;
+    std::unique_ptr<rdma::RdmaHandshakeAdapter> protocol;
     rdma::ParsedHello remote{};
     handshake::ServerHandshakeCallbacks callbacks{};
     callbacks.phases = handshake::HandshakePhases{
         S_ALLOC_QPCQ, S_HELLO_SEND, S_HELLO_WAIT,
         S_BRINGUP_QP, 0, S_ACK_WAIT};
-    callbacks.blocking = false;
     callbacks.fallback_on_not_mine = false;
     callbacks.receive_remote_hello = [&]() {
         if (source->size() < rdma::HELLO_MAGIC_LEN) {
@@ -197,7 +197,7 @@ ParseResult RdmaTransport::ExecuteServerHandshake(butil::IOBuf* source,
         }
         uint8_t magic[rdma::HELLO_MAGIC_LEN];
         CHECK_EQ(source->copy_to(magic, sizeof(magic)), sizeof(magic));
-        protocol = rdma::CreateServerHandshakeByMagic(
+        protocol = rdma::CreateServerHandshakeAdapterByMagic(
             ep, transport->_handshake.io(), source, magic);
         if (protocol == NULL) {
             return handshake::STEP_NOT_MINE;
@@ -218,7 +218,7 @@ ParseResult RdmaTransport::ExecuteServerHandshake(butil::IOBuf* source,
         return handshake::STEP_FALLBACK;
     };
     callbacks.prepare_local = [&]() {
-        ep->ApplyRemoteHello(remote);
+        ep->ApplyRemoteInfo(remote);
         if (ep->AllocateResources() < 0) {
             PLOG(WARNING) << "Fail to allocate rdma resources, fallback to tcp:"
                           << socket->description();
@@ -234,9 +234,9 @@ ParseResult RdmaTransport::ExecuteServerHandshake(butil::IOBuf* source,
         }
         return handshake::STEP_OK;
     };
-    callbacks.send_local_hello = [&](bool) {
+    callbacks.send_local_hello = [&](bool enabled) {
         CHECK(protocol != NULL);
-        return protocol->SendLocalHello() == 0
+        return protocol->SendLocalHello(enabled) == 0
             ? handshake::STEP_OK : handshake::STEP_ERROR;
     };
     callbacks.receive_ack = [&]() {
@@ -305,12 +305,12 @@ void RdmaTransport::Init(Socket *socket, const SocketOptions &options) {
         // ProcessHandshakeAtClient is an active blocking bthread relying on
         // HandshakeSession being woken by OnNewDataFromTcp.
         if (options.user == static_cast<SocketUser*>(get_client_side_messenger())) {
-            default_on_edge = UpgradeTransport::OnNewDataFromTcp;
+            default_on_edge = AdapterTransport::OnNewDataFromTcp;
         } else {
             default_on_edge = InputMessenger::OnNewMessages;
         }
     }
-    InitUpgradeTransport(socket, options, default_on_edge);
+    InitAdapterTransport(socket, options, default_on_edge);
 }
 
 void RdmaTransport::Release() {
@@ -326,7 +326,7 @@ int RdmaTransport::Reset(int32_t expected_nref) {
         _rdma_ep->Reset();
         _rdma_state = RDMA_UNKNOWN;
     }
-    ResetUpgradeTransport();
+    ResetAdapterTransport();
     return 0;
 }
 
diff --git a/src/brpc/rdma_transport.h b/src/brpc/rdma_transport.h
index 2031c2cbac..8dea37b6ae 100644
--- a/src/brpc/rdma_transport.h
+++ b/src/brpc/rdma_transport.h
@@ -21,15 +21,13 @@
 #if BRPC_WITH_RDMA
 #include "brpc/socket.h"
 #include "brpc/channel.h"
-#include "brpc/upgrade_transport.h"
+#include "brpc/adapter_transport.h"
 
 namespace brpc {
-class RdmaTransport : public UpgradeTransport {
+class RdmaTransport : public AdapterTransport {
     friend class TransportFactory;
     friend class rdma::RdmaEndpoint;
     friend class rdma::RdmaConnect;
-    friend class rdma::RdmaHandshakeServerV2;
-    friend class rdma::RdmaHandshakeServerV3;
 public:
     enum HandshakeState {
         UNINIT = 0x0,
diff --git a/src/brpc/socket.h b/src/brpc/socket.h
index 529f1d8777..cf5086897b 100644
--- a/src/brpc/socket.h
+++ b/src/brpc/socket.h
@@ -56,10 +56,6 @@ class ChannelBalancer;
 namespace rdma {
 class RdmaEndpoint;
 class RdmaConnect;
-class RdmaHandshakeClientV2;
-class RdmaHandshakeServerV2;
-class RdmaHandshakeClientV3;
-class RdmaHandshakeServerV3;
 }
 namespace ubring {
     class UBShmEndpoint;
@@ -70,7 +66,7 @@ class AuthContext;
 class EventDispatcher;
 class Stream;
 class Transport;
-class UpgradeTransport;
+class AdapterTransport;
 
 // Set SO_SNDBUF/SO_RCVBUF according to socket_*_buffer_size flags.
 void SetSocketBufferOptions(int fd);
@@ -331,10 +327,6 @@ friend class rdma::RdmaConnect;
 friend class ubring::UBShmEndpoint;
 friend class ubring::UBConnect;
 friend class UBShmTransport;
-friend class rdma::RdmaHandshakeClientV2;
-friend class rdma::RdmaHandshakeServerV2;
-friend class rdma::RdmaHandshakeClientV3;
-friend class rdma::RdmaHandshakeServerV3;
 friend class HealthCheckTask;
 friend class OnAppHealthCheckDone;
 friend class HealthCheckManager;
@@ -343,7 +335,7 @@ friend class VersionedRefWithId<Socket>;
 friend class IOEvent<Socket>;
 friend void DereferenceSocket(Socket*);
 friend class Transport;
-friend class UpgradeTransport;
+friend class AdapterTransport;
 friend class TcpTransport;
 friend class RdmaTransport;
 friend class TransportFactory;
diff --git a/src/brpc/transport_handshake.cpp b/src/brpc/transport_handshake.cpp
index 3258e749df..e8dca5aacf 100644
--- a/src/brpc/transport_handshake.cpp
+++ b/src/brpc/transport_handshake.cpp
@@ -274,11 +274,12 @@ StepResult HandshakeSession::RunServer(
             return FinishWithFailure(this, callbacks.on_failed);
         }
         SetPhase(callbacks.phases.ack_wait);
-        if (!callbacks.blocking) {
-            return STEP_NEED_MORE;
-        }
     }
 
+    // Always try the ACK callback once. For a non-blocking server it returns
+    // STEP_NEED_MORE when the ACK has not arrived; when Hello and ACK are
+    // coalesced in the input buffer this consumes the ACK without waiting for
+    // another socket edge.
     StepResult result = callbacks.receive_ack();
     if (result == STEP_NEED_MORE) {
         return STEP_NEED_MORE;
diff --git a/src/brpc/transport_handshake.h b/src/brpc/transport_handshake.h
index d84436ff1b..b2d0b643a2 100644
--- a/src/brpc/transport_handshake.h
+++ b/src/brpc/transport_handshake.h
@@ -40,7 +40,7 @@ struct ServerHandshakeContext : public Destroyable {
 };
 
 // Protocol adapters may use transport-specific intermediate values, but the
-// terminal values are shared so that UpgradeTransport can make the same
+// terminal values are shared so that AdapterTransport can make the same
 // acquire-side decision for RDMA, URMA and UBSHM.
 enum Phase {
     UNINITIALIZED = 0,
@@ -81,11 +81,10 @@ struct ClientHandshakeCallbacks {
     std::function<void()> on_failed;
 };
 
-// The server driver can operate incrementally (InputMessenger parser) or run
-// through ACK_WAIT in one blocking handshake bthread.
+// The server driver is independent of the input mode. A parser callback can
+// return STEP_NEED_MORE, while a blocking callback waits before returning.
 struct ServerHandshakeCallbacks {
     HandshakePhases phases;
-    bool blocking;
     bool fallback_on_not_mine;
     std::function<StepResult()> receive_remote_hello;
     std::function<StepResult()> prepare_local;
diff --git a/src/brpc/ubshm/ub_endpoint.cpp b/src/brpc/ubshm/ub_endpoint.cpp
index ac85f75207..0b04a38b50 100644
--- a/src/brpc/ubshm/ub_endpoint.cpp
+++ b/src/brpc/ubshm/ub_endpoint.cpp
@@ -358,7 +358,6 @@ void* UBShmTransport::ProcessHandshakeAtServer(void* arg) {
     callbacks.phases = handshake::HandshakePhases{
         S_ALLOC_SHM, S_HELLO_SEND, S_HELLO_WAIT,
         S_ALLOC_SHM, 0, S_ACK_WAIT};
-    callbacks.blocking = true;
     callbacks.fallback_on_not_mine = true;
     callbacks.receive_remote_hello = [&]() {
         if (ub_transport->_handshake.io()->ReadExact(
diff --git a/src/brpc/ubshm_transport.cpp b/src/brpc/ubshm_transport.cpp
index 2b36e5508a..8a09deabc1 100644
--- a/src/brpc/ubshm_transport.cpp
+++ b/src/brpc/ubshm_transport.cpp
@@ -42,7 +42,7 @@ void UBShmTransport::Init(Socket *socket, const SocketOptions &options) {
         _ub_state = UB_OFF;
         socket->_socket_mode = SOCKET_MODE_TCP;
     }
-    InitUpgradeTransport(socket, options, UpgradeTransport::OnNewDataFromTcp);
+    InitAdapterTransport(socket, options, AdapterTransport::OnNewDataFromTcp);
 }
 
 void UBShmTransport::Release() {
@@ -58,7 +58,7 @@ int UBShmTransport::Reset(int32_t expected_nref) {
         _ub_ep->Reset();
         _ub_state = UB_UNKNOWN;
     }
-    ResetUpgradeTransport();
+    ResetAdapterTransport();
     return 0;
 }
 
diff --git a/src/brpc/ubshm_transport.h b/src/brpc/ubshm_transport.h
index ed79fb0815..e756f049c6 100644
--- a/src/brpc/ubshm_transport.h
+++ b/src/brpc/ubshm_transport.h
@@ -20,10 +20,10 @@
 #if BRPC_WITH_UBRING
 #include "brpc/socket.h"
 #include "brpc/channel.h"
-#include "brpc/upgrade_transport.h"
+#include "brpc/adapter_transport.h"
 
 namespace brpc {
-class UBShmTransport : public UpgradeTransport {
+class UBShmTransport : public AdapterTransport {
     friend class TransportFactory;
     friend class ubring::UBShmEndpoint;
     friend class ubring::UBConnect;
diff --git a/test/brpc_rdma_unittest.cpp b/test/brpc_rdma_unittest.cpp
index 2ecd1f3cac..b45b677d4e 100644
--- a/test/brpc_rdma_unittest.cpp
+++ b/test/brpc_rdma_unittest.cpp
@@ -38,9 +38,9 @@
 #include "brpc/rdma_transport.h"
 #include "brpc/rdma/block_pool.h"
 #include "brpc/rdma/rdma_endpoint.h"
-#include "brpc/rdma/rdma_handshake.h"
-#include "brpc/rdma/rdma_handshake_constants.h"
-#include "brpc/rdma/rdma_handshake.pb.h"
+#include "brpc/rdma_handshake.h"
+#include "brpc/rdma_handshake_constants.h"
+#include "brpc/rdma_handshake.pb.h"
 #include "brpc/rdma/rdma_helper.h"
 #include "echo.pb.h"
 
@@ -57,7 +57,7 @@ DEFINE_bool(rdma_test_enable, false, "Enable tests requring rdma runtime.");
 namespace rdma {
 
 // HELLO_V2_VERSION / IMPL_V2_VERSION come from
-// brpc/rdma/rdma_handshake_constants.h (shared wire constants).
+// brpc/rdma_handshake_constants.h (shared wire constants).
 
 DECLARE_bool(rdma_trace_verbose);
 DECLARE_int32(rdma_memory_pool_max_regions);
@@ -200,7 +200,7 @@ TEST_F(RdmaTest, client_close_before_hello_send) {
     ASSERT_EQ(0, connect(sockfd, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     Socket* s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     close(sockfd);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -221,7 +221,7 @@ TEST_F(RdmaTest, client_hello_msg_invalid_magic_str) {
     ASSERT_EQ(0, connect(sockfd, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     Socket* s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     uint8_t data[rdma::HELLO_V2_MSG_LEN_MIN];
     memcpy(data, "PRPC", 4);  // send as normal baidu_std protocol
@@ -230,7 +230,7 @@ TEST_F(RdmaTest, client_hello_msg_invalid_magic_str) {
     // A non-RDMA magic makes ParseRdmaHandshake return TRY_OTHERS and hand the
     // bytes to other protocols; it does not touch the endpoint state, so it
     // stays UNINIT (the old blocking handshake used to set FALLBACK_TCP here).
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     StopServer();
 }
@@ -250,14 +250,14 @@ TEST_F(RdmaTest, client_close_during_hello_send) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     memcpy(data, "RD", 2);
     ASSERT_EQ(2, write(sockfd1, data, 2));  // break in magic str
     usleep(100000);  // wait for server to handle the msg
     // Fewer than 4 magic bytes: ParseRdmaHandshake can't tell yet, returns
     // NOT_ENOUGH_DATA and leaves the endpoint UNINIT (the old blocking
     // handshake used to set S_HELLO_WAIT before reading the magic).
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     close(sockfd1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -267,11 +267,11 @@ TEST_F(RdmaTest, client_close_during_hello_send) {
     ASSERT_EQ(0, connect(sockfd2, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     memcpy(data, "RDMA", 4);
     ASSERT_EQ(4, write(sockfd2, data, 4));  // break after magic str
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     close(sockfd2);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -281,7 +281,7 @@ TEST_F(RdmaTest, client_close_during_hello_send) {
     ASSERT_EQ(0, connect(sockfd3, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     // Send the 4B magic plus a valid msg_len (=40) but no body, so the server
     // recognizes an RDMA v2 hello and waits for the remaining bytes. (A zero
     // msg_len would now be rejected up-front as a protocol error.)
@@ -290,7 +290,7 @@ TEST_F(RdmaTest, client_close_during_hello_send) {
     memcpy(data + 4, &v2_len, sizeof(v2_len));
     ASSERT_EQ(6, write(sockfd3, data, 6));  // magic + msg_len, body missing
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     close(sockfd3);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -313,11 +313,11 @@ TEST_F(RdmaTest, client_hello_msg_invalid_len) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     memcpy(data, "RDMA", 4);
     ASSERT_EQ(4, write(sockfd1, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     memset(data + 4, 0, 36);
     ASSERT_EQ(36, write(sockfd1, data + 4, 36));  // Write invalid length.
     usleep(100000);  // wait for server to handle the msg
@@ -328,11 +328,11 @@ TEST_F(RdmaTest, client_hello_msg_invalid_len) {
     ASSERT_EQ(0, connect(sockfd2, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     memcpy(data, "RDMA", 4);
     ASSERT_EQ(4, write(sockfd2, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     uint16_t len = butil::HostToNet16(35);
     memcpy(data + 4, &len, sizeof(len));
     memset(data + 6, 0, 34);
@@ -360,11 +360,11 @@ TEST_F(RdmaTest, client_hello_msg_invalid_version) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     memcpy(data, "RDMA", 4);
     ASSERT_EQ(4, write(sockfd1, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     memcpy(data + 4, &len, 2);
     memset(data + 6, 0, 34);
     memcpy(data + 6, &ver, 2);  // hello_ver == 1, impl_ver == 0
@@ -377,12 +377,12 @@ TEST_F(RdmaTest, client_hello_msg_invalid_version) {
     // version check, breaking the intent of this UT.
     ASSERT_EQ(36, write(sockfd1, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_state);
     uint32_t flags = 0;
     ASSERT_EQ(sizeof(flags), write(sockfd1, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     sockfd1.reset(-1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -392,11 +392,11 @@ TEST_F(RdmaTest, client_hello_msg_invalid_version) {
     ASSERT_EQ(0, connect(sockfd2, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     memcpy(data, "RDMA", 4);
     ASSERT_EQ(4, write(sockfd2, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     memcpy(data + 4, &len, 2);
     memset(data + 6, 0, 32);
     memcpy(data + 8, &ver, 2);  // hello_ver == 0, impl_ver == 1
@@ -404,11 +404,11 @@ TEST_F(RdmaTest, client_hello_msg_invalid_version) {
     // write from data + 4 instead of data.
     ASSERT_EQ(36, write(sockfd2, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_state);
     ASSERT_EQ(sizeof(flags), write(sockfd2, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     sockfd2.reset(-1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -441,17 +441,17 @@ TEST_F(RdmaTest, client_hello_msg_invalid_sq_rq_block_size) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(4, write(sockfd1, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(36, write(sockfd1, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_state);
     ASSERT_EQ(sizeof(flags), write(sockfd1, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     sockfd1.reset(-1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -466,17 +466,17 @@ TEST_F(RdmaTest, client_hello_msg_invalid_sq_rq_block_size) {
     ASSERT_EQ(0, connect(sockfd2, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(4, write(sockfd2, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(36, write(sockfd2, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_state);
     ASSERT_EQ(sizeof(flags), write(sockfd2, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     sockfd2.reset(-1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -491,17 +491,17 @@ TEST_F(RdmaTest, client_hello_msg_invalid_sq_rq_block_size) {
     ASSERT_EQ(0, connect(sockfd3, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(4, write(sockfd3, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(36, write(sockfd3, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_state);
     ASSERT_EQ(sizeof(flags), write(sockfd3, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     sockfd3.reset(-1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -535,10 +535,10 @@ TEST_F(RdmaTest, client_close_after_qp_build) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(40, write(sockfd1, data, 40));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     close(sockfd1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -572,17 +572,17 @@ TEST_F(RdmaTest, client_close_during_ack_send) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(4, write(sockfd1, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(36, write(sockfd1, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     uint32_t flags = butil::HostToNet32(1);
     ASSERT_EQ(sizeof(flags), write(sockfd1, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     close(sockfd1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -616,17 +616,17 @@ TEST_F(RdmaTest, client_close_after_ack_send) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(4, write(sockfd1, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(36, write(sockfd1, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     uint32_t flags = butil::HostToNet32(0);
     ASSERT_EQ(sizeof(flags), write(sockfd1, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_state);
     close(sockfd1);
     usleep(100000);  // wait for server to handle the msg
@@ -637,17 +637,17 @@ TEST_F(RdmaTest, client_close_after_ack_send) {
     ASSERT_EQ(0, connect(sockfd2, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(4, write(sockfd2, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(36, write(sockfd2, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     flags = butil::HostToNet32(1);
     ASSERT_EQ(sizeof(flags), write(sockfd2, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     close(sockfd2);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -681,17 +681,17 @@ TEST_F(RdmaTest, client_send_data_on_tcp_after_ack_send) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(4, write(sockfd1, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(36, write(sockfd1, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     uint32_t flags = butil::HostToNet32(0);
     ASSERT_EQ(sizeof(flags), write(sockfd1, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(sizeof(flags), write(sockfd1, &flags, sizeof(flags)));
     usleep(100000);
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -701,17 +701,17 @@ TEST_F(RdmaTest, client_send_data_on_tcp_after_ack_send) {
     ASSERT_EQ(0, connect(sockfd2, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(4, write(sockfd2, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(36, write(sockfd2, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     flags = butil::HostToNet32(1);
     ASSERT_EQ(sizeof(flags), write(sockfd2, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(rdma::RdmaEndpoint::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(sizeof(flags), write(sockfd2, &flags, sizeof(flags)));
     usleep(100000);
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -741,7 +741,7 @@ TEST_F(RdmaTest, server_miss_before_hello_send) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(rdma::RdmaEndpoint::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -772,7 +772,7 @@ TEST_F(RdmaTest, server_close_before_hello_send) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(rdma::RdmaEndpoint::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -780,7 +780,7 @@ TEST_F(RdmaTest, server_close_before_hello_send) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, read(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     close(acc_fd);
     usleep(100000);
-    ASSERT_EQ(rdma::RdmaEndpoint::FAILED, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FAILED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     bthread_id_join(cntl.call_id());
 
     ASSERT_EQ(EEOF, cntl.ErrorCode());
@@ -808,7 +808,7 @@ TEST_F(RdmaTest, server_miss_during_magic_str) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(rdma::RdmaEndpoint::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -843,7 +843,7 @@ TEST_F(RdmaTest, server_close_during_magic_str) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(rdma::RdmaEndpoint::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -853,7 +853,7 @@ TEST_F(RdmaTest, server_close_during_magic_str) {
     usleep(100000);
     close(acc_fd);
     usleep(100000);
-    ASSERT_EQ(rdma::RdmaEndpoint::FAILED, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FAILED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     bthread_id_join(cntl.call_id());
 
     ASSERT_EQ(EEOF, cntl.ErrorCode());
@@ -881,7 +881,7 @@ TEST_F(RdmaTest, server_hello_invalid_magic_str) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(rdma::RdmaEndpoint::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -889,7 +889,7 @@ TEST_F(RdmaTest, server_hello_invalid_magic_str) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, read(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     ASSERT_EQ(4, write(acc_fd, "ABCD", 4));
     usleep(100000);
-    ASSERT_EQ(rdma::RdmaEndpoint::FAILED, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FAILED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     bthread_id_join(cntl.call_id());
 
     ASSERT_EQ(EPROTO, cntl.ErrorCode());
@@ -917,7 +917,7 @@ TEST_F(RdmaTest, server_miss_during_hello_msg) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(rdma::RdmaEndpoint::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -952,7 +952,7 @@ TEST_F(RdmaTest, server_close_during_hello_msg) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(rdma::RdmaEndpoint::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -962,7 +962,7 @@ TEST_F(RdmaTest, server_close_during_hello_msg) {
     ASSERT_EQ(2, write(acc_fd, "00", 2));
     close(acc_fd);
     usleep(100000);
-    ASSERT_EQ(rdma::RdmaEndpoint::FAILED, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FAILED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     bthread_id_join(cntl.call_id());
 
     ASSERT_EQ(EEOF, cntl.ErrorCode());
@@ -990,7 +990,7 @@ TEST_F(RdmaTest, server_hello_invalid_msg_len) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(rdma::RdmaEndpoint::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -1002,7 +1002,7 @@ TEST_F(RdmaTest, server_hello_invalid_msg_len) {
     memset(data + 6, 0, 32);
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     usleep(100000);
-    ASSERT_EQ(rdma::RdmaEndpoint::FAILED, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FAILED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     bthread_id_join(cntl.call_id());
 
     ASSERT_EQ(EPROTO, cntl.ErrorCode());
@@ -1030,7 +1030,7 @@ TEST_F(RdmaTest, server_hello_invalid_version) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(rdma::RdmaEndpoint::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -1042,7 +1042,7 @@ TEST_F(RdmaTest, server_hello_invalid_version) {
     memset(data + 6, 0, 32);
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     usleep(100000);
-    ASSERT_EQ(rdma::RdmaEndpoint::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(4, read(acc_fd, data, 4));
     uint32_t* tmp = (uint32_t*)data;
     ASSERT_EQ(0, butil::NetToHost32(*tmp));
@@ -1073,7 +1073,7 @@ TEST_F(RdmaTest, server_hello_invalid_sq_rq_size) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(rdma::RdmaEndpoint::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -1094,7 +1094,7 @@ TEST_F(RdmaTest, server_hello_invalid_sq_rq_size) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
 
     usleep(100000);
-    ASSERT_EQ(rdma::RdmaEndpoint::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(4, read(acc_fd, data, 4));
     uint32_t* tmp = (uint32_t*)data;
     ASSERT_EQ(0, butil::NetToHost32(*tmp));
@@ -1125,7 +1125,7 @@ TEST_F(RdmaTest, server_miss_after_ack) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(rdma::RdmaEndpoint::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -1146,7 +1146,7 @@ TEST_F(RdmaTest, server_miss_after_ack) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
 
     usleep(100000);
-    ASSERT_EQ(rdma::RdmaEndpoint::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(4, read(acc_fd, data, 4));
     uint32_t* tmp = (uint32_t*)data;
     ASSERT_EQ(1, butil::NetToHost32(*tmp));
@@ -1177,7 +1177,7 @@ TEST_F(RdmaTest, server_close_after_ack) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(rdma::RdmaEndpoint::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -1198,7 +1198,7 @@ TEST_F(RdmaTest, server_close_after_ack) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
 
     usleep(100000);
-    ASSERT_EQ(rdma::RdmaEndpoint::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(4, read(acc_fd, data, 4));
     uint32_t* tmp = (uint32_t*)data;
     ASSERT_EQ(1, butil::NetToHost32(*tmp));
@@ -1230,7 +1230,7 @@ TEST_F(RdmaTest, server_send_data_on_tcp_after_ack) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(rdma::RdmaEndpoint::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -1251,7 +1251,7 @@ TEST_F(RdmaTest, server_send_data_on_tcp_after_ack) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
 
     usleep(100000);
-    ASSERT_EQ(rdma::RdmaEndpoint::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     bthread_id_join(cntl.call_id());
 
@@ -1322,7 +1322,7 @@ TEST_F(RdmaTest, v2_server_hello_bytes_baseline) {
     ASSERT_EQ(0, connect(sockfd, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);
     Socket* s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     // Send a well-formed v2 hello so the server enters S_ACK_WAIT.
     rdma::v2_wire::HelloMessage msg{};
@@ -1340,7 +1340,7 @@ TEST_F(RdmaTest, v2_server_hello_bytes_baseline) {
     msg.Serialize(data + 4);
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(sockfd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     usleep(100000);
-    ASSERT_EQ(rdma::RdmaEndpoint::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     // Read server's reply hello and assert its byte-level layout.
     uint8_t reply[rdma::HELLO_V2_MSG_LEN_MIN];
@@ -1365,7 +1365,7 @@ TEST_F(RdmaTest, v2_server_hello_bytes_baseline) {
     uint32_t flags = butil::HostToNet32(0);
     ASSERT_EQ(sizeof(flags), write(sockfd, &flags, sizeof(flags)));
     usleep(100000);
-    ASSERT_EQ(rdma::RdmaEndpoint::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     sockfd.reset(-1);
     usleep(100000);
@@ -1374,7 +1374,7 @@ TEST_F(RdmaTest, v2_server_hello_bytes_baseline) {
     StopServer();
 }
 
-TEST_F(RdmaTest, v2_server_drains_tail_then_reads_ack) {
+TEST_F(RdmaTest, v2_server_preserves_coalesced_ack_after_extension) {
     StartServer();
 
     sockaddr_in addr;
@@ -1387,7 +1387,7 @@ TEST_F(RdmaTest, v2_server_drains_tail_then_reads_ack) {
     usleep(100000);
     Socket* s = GetSocketFromServer(0);
     ASSERT_TRUE(s != NULL);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     // Build a v2 hello with msg_len = 48 (40 base + 8B zero tail).
     rdma::v2_wire::HelloMessage msg{};
@@ -1400,19 +1400,18 @@ TEST_F(RdmaTest, v2_server_drains_tail_then_reads_ack) {
     msg.qp_num = 0;
     msg.gid = rdma::GetRdmaGid();
 
-    uint8_t buf[48];
+    uint8_t buf[52];
     memcpy(buf, "RDMA", 4);
     msg.Serialize(buf + 4);
     memset(buf + 40, 0x00, 8);  // 8B zero tail
-    ASSERT_EQ(48, write(sockfd, buf, 48));
-    usleep(100000);
-
-    // Send the real ACK (flags=1 = ACK_MSG_RDMA_OK).
+    // Coalesce the real ACK with the hello. The v2 parser must consume only
+    // msg_len bytes and preserve the ACK for the next handshake step.
     uint32_t flags = butil::HostToNet32(1);
-    ASSERT_EQ(sizeof(flags), write(sockfd, &flags, sizeof(flags)));
+    memcpy(buf + 48, &flags, sizeof(flags));
+    ASSERT_EQ(sizeof(buf), write(sockfd, buf, sizeof(buf)));
     usleep(100000);
 
-    ASSERT_EQ(rdma::RdmaEndpoint::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     sockfd.reset(-1);
     usleep(100000);
@@ -1434,7 +1433,7 @@ TEST_F(RdmaTest, v2_server_rejects_oversized_msg_len) {
     usleep(100000);
     Socket* s = GetSocketFromServer(0);
     ASSERT_TRUE(s != NULL);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     // Build a v2 hello with msg_len = 4097 (HELLO_V2_MSG_LEN_MAX + 1).
     // We only send the 40B base; the server must reject before reading
@@ -1585,14 +1584,14 @@ TEST_F(RdmaTest, v3_server_hello_bytes_baseline) {
     ASSERT_EQ(0, connect(sockfd, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);
     Socket* s = GetSocketFromServer(0);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     // Send a valid v3 hello.
     std::string packet = MakeV3Packet(MakeValidV3Hello());
     ASSERT_EQ((ssize_t)packet.size(),
               write(sockfd, packet.data(), packet.size()));
     usleep(100000);
-    ASSERT_EQ(rdma::RdmaEndpoint::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     // Read server's reply hello: 4B magic + 4B pb_size + body.
     uint8_t reply_magic[4];
@@ -1622,7 +1621,7 @@ TEST_F(RdmaTest, v3_server_hello_bytes_baseline) {
     ASSERT_EQ((ssize_t)sizeof(flags),
               write(sockfd, &flags, sizeof(flags)));
     usleep(100000);
-    ASSERT_EQ(rdma::RdmaEndpoint::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     sockfd.reset(-1);
     usleep(100000);
@@ -1737,7 +1736,7 @@ TEST_F(RdmaTest, v3_server_invalid_sq_size_falls_back) {
 
     // Server validated the hello as invalid -> _rdma_state = RDMA_OFF,
     // but still proceeds to S_ACK_WAIT (sends its own reply hello).
-    ASSERT_EQ(rdma::RdmaEndpoint::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_state);
 
     // Drain server's reply hello (content not asserted here; covered
@@ -1756,7 +1755,7 @@ TEST_F(RdmaTest, v3_server_invalid_sq_size_falls_back) {
     ASSERT_EQ((ssize_t)sizeof(flags),
               write(sockfd, &flags, sizeof(flags)));
     usleep(100000);
-    ASSERT_EQ(rdma::RdmaEndpoint::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     sockfd.reset(-1);
     usleep(100000);
@@ -1828,8 +1827,8 @@ TEST_F(RdmaTest, v3_server_accepts_client_hello_with_ece) {
               write(sockfd, packet.data(), packet.size()));
     usleep(100000);
 
-    ASSERT_EQ(rdma::RdmaEndpoint::S_ACK_WAIT,
-              static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT,
+              static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     rdma::RdmaHello reply;
     ReadServerV3Reply(sockfd, &reply);
@@ -1838,8 +1837,8 @@ TEST_F(RdmaTest, v3_server_accepts_client_hello_with_ece) {
     uint32_t flags = butil::HostToNet32(0);
     ASSERT_EQ((ssize_t)sizeof(flags), write(sockfd, &flags, sizeof(flags)));
     usleep(100000);
-    ASSERT_EQ(rdma::RdmaEndpoint::FALLBACK_TCP,
-              static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP,
+              static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     sockfd.reset(-1);
     usleep(100000);
@@ -1956,8 +1955,8 @@ TEST_F(RdmaTest, client_alloc_resource_fail_fallback_tcp) {
 
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(rdma::RdmaEndpoint::FALLBACK_TCP,
-              static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP,
+              static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF,
               static_cast<RdmaTransport*>(s->_transport.get())->_rdma_state);
     // The socket must not be failed, otherwise it can no longer carry TCP.
@@ -1984,8 +1983,8 @@ TEST_F(RdmaTest, server_alloc_resource_fail_fallback_tcp) {
     usleep(100000);  // wait for server to handle the msg
     Socket* s = GetSocketFromServer(0);
     ASSERT_TRUE(s != NULL);
-    ASSERT_EQ(rdma::RdmaEndpoint::UNINIT,
-              static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::UNINIT,
+              static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
 
     // Send a well-formed v2 hello: the negotiation succeeds
     // but the resource allocation does not.
@@ -2005,8 +2004,8 @@ TEST_F(RdmaTest, server_alloc_resource_fail_fallback_tcp) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN,
               write(sockfd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     usleep(100000);
-    ASSERT_EQ(rdma::RdmaEndpoint::S_ACK_WAIT,
-              static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT,
+              static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF,
               static_cast<RdmaTransport*>(s->_transport.get())->_rdma_state);
     ASSERT_FALSE(s->Failed());
@@ -2015,8 +2014,8 @@ TEST_F(RdmaTest, server_alloc_resource_fail_fallback_tcp) {
     uint32_t flags = butil::HostToNet32(0);
     ASSERT_EQ(sizeof(flags), write(sockfd, &flags, sizeof(flags)));
     usleep(100000);
-    ASSERT_EQ(rdma::RdmaEndpoint::FALLBACK_TCP,
-              static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP,
+              static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     ASSERT_FALSE(s->Failed());
 
     sockfd.reset(-1);
@@ -2048,7 +2047,7 @@ TEST_F(RdmaTest, try_global_disable_rdma) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(rdma::RdmaEndpoint::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_ep->_state);
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
     bthread_id_join(cntl.call_id());
     ASSERT_EQ(0, cntl.ErrorCode());
 
diff --git a/test/brpc_transport_handshake_unittest.cpp b/test/brpc_transport_handshake_unittest.cpp
index f7f08d4551..8289314cb7 100644
--- a/test/brpc_transport_handshake_unittest.cpp
+++ b/test/brpc_transport_handshake_unittest.cpp
@@ -125,7 +125,6 @@ TEST(TransportHandshakeTest, server_driver_resumes_at_ack_wait) {
 
     ServerHandshakeCallbacks callbacks{};
     callbacks.phases = HandshakePhases{11, 12, 13, 14, 15, 16};
-    callbacks.blocking = false;
     callbacks.fallback_on_not_mine = false;
     callbacks.receive_remote_hello = [&]() {
         ++hello_calls;
@@ -139,7 +138,7 @@ TEST(TransportHandshakeTest, server_driver_resumes_at_ack_wait) {
     };
     callbacks.receive_ack = [&]() {
         ++ack_calls;
-        return STEP_OK;
+        return ack_calls == 1 ? STEP_NEED_MORE : STEP_OK;
     };
     callbacks.set_high_speed_active = [&]() {
         high_speed_active = true;
@@ -150,11 +149,11 @@ TEST(TransportHandshakeTest, server_driver_resumes_at_ack_wait) {
     ASSERT_EQ(STEP_NEED_MORE, session.RunServer(callbacks));
     ASSERT_EQ(16, session.phase());
     ASSERT_EQ(1, hello_calls);
-    ASSERT_EQ(0, ack_calls);
+    ASSERT_EQ(1, ack_calls);
 
     ASSERT_EQ(STEP_OK, session.RunServer(callbacks));
     ASSERT_EQ(1, hello_calls);
-    ASSERT_EQ(1, ack_calls);
+    ASSERT_EQ(2, ack_calls);
     ASSERT_TRUE(high_speed_active);
     ASSERT_EQ(ESTABLISHED, session.phase());
 }
@@ -165,7 +164,6 @@ TEST(TransportHandshakeTest, server_driver_runs_blocking_handshake) {
 
     ServerHandshakeCallbacks callbacks{};
     callbacks.phases = HandshakePhases{11, 12, 13, 14, 15, 16};
-    callbacks.blocking = true;
     callbacks.fallback_on_not_mine = true;
     callbacks.receive_remote_hello = [&]() {
         calls += "recv_hello ";
@@ -204,7 +202,6 @@ TEST(TransportHandshakeTest, server_driver_falls_back_for_other_protocol) {
 
     ServerHandshakeCallbacks callbacks{};
     callbacks.phases = HandshakePhases{11, 12, 13, 14, 15, 16};
-    callbacks.blocking = true;
     callbacks.fallback_on_not_mine = true;
     callbacks.receive_remote_hello = []() { return STEP_NOT_MINE; };
     callbacks.prepare_local = []() { return STEP_ERROR; };

From 86848cde743dba41949bbfb1dcaeebbfe81f0478 Mon Sep 17 00:00:00 2001
From: Gzure <740684863@qq.com>
Date: Tue, 18 Aug 2026 17:47:35 +0800
Subject: [PATCH 06/11] Make AdapterTransport the top-level transport

---
 docs/cn/handshake_common_design.md |  58 ++++----
 src/brpc/adapter_transport.cpp     | 154 +++++++++++++++++---
 src/brpc/adapter_transport.h       |  58 ++++----
 src/brpc/rdma/rdma_endpoint.cpp    |   2 +-
 src/brpc/rdma_transport.cpp        | 100 +++++++------
 src/brpc/rdma_transport.h          |  26 +++-
 src/brpc/socket.h                  |   4 +-
 src/brpc/transport_factory.cpp     |  10 +-
 src/brpc/transport_factory.h       |   5 +-
 src/brpc/ubshm/ub_endpoint.cpp     |  31 +++--
 src/brpc/ubshm_transport.cpp       |  67 ++++++---
 src/brpc/ubshm_transport.h         |  26 ++--
 test/brpc_rdma_unittest.cpp        | 216 ++++++++++++++---------------
 13 files changed, 484 insertions(+), 273 deletions(-)

diff --git a/docs/cn/handshake_common_design.md b/docs/cn/handshake_common_design.md
index 83b6f91b84..d7e63d7206 100644
--- a/docs/cn/handshake_common_design.md
+++ b/docs/cn/handshake_common_design.md
@@ -118,13 +118,13 @@ Hello 中携带：
 
 ```text
 src/brpc/
-    adapter_transport.h/.cpp     # TCP-first 路由、适配器切换与状态发布
+    adapter_transport.h/.cpp     # Socket 顶层 Transport、TCP-first 路由与状态发布
     transport_handshake.h/.cpp   # HandshakeSession 与 SocketHandshakeIO
     rdma_handshake.h/.cpp        # RDMA v2/v3 wire adapter
     rdma_handshake_server.h/.cpp # RDMA 标准 server parser/fallback
     rdma_handshake.proto         # RDMA v3 wire message
-    rdma_transport.h/.cpp        # RDMA 握手回调与 Endpoint adapter
-    ubshm_transport.h/.cpp       # UBSHM 协议状态机与 Endpoint adapter
+    rdma_transport.h/.cpp        # 独立 RDMA Transport、握手回调与数据面
+    ubshm_transport.h/.cpp       # 独立 UBSHM Transport、握手回调与数据面
 ```
 
 总体关系如下：
@@ -135,15 +135,16 @@ flowchart TB
     UT --> TCP["TcpTransport\n默认数据面 / fallback"]
     UT --> HS["HandshakeSession\nclient/server driver + lifecycle"]
     HS --> IO["SocketHandshakeIO\nReadExact / WriteAll / readable butex"]
-    UT --> RA["RDMA adapter"]
-    UT --> UA["URMA adapter"]
-    UT --> BA["UBSHM adapter"]
-    RA --> RE["RdmaEndpoint\nQP / CQ / MR"]
-    UA --> UE["UrmaEndpoint\nJetty / JFC / Segment"]
-    BA --> BE["UBShmEndpoint\nUBRing / Shared Memory"]
+    UT --> RT["RdmaTransport"]
+    UT --> UTRA["UrmaTransport"]
+    UT --> BT["UBShmTransport"]
+    RT --> RA["RDMA handshake adapter"]
+    RT --> RE["RdmaEndpoint\nQP / CQ / MR"]
+    UTRA --> UE["UrmaEndpoint\nJetty / JFC / Segment"]
+    BT --> BE["UBShmEndpoint\nUBRing / Shared Memory"]
 ```
 
-`AdapterTransport` 决定当前数据走 TCP 还是高速 Endpoint；`HandshakeSession` 驱动一次升级尝试的公共步骤；具体 adapter 通过回调完成 Hello/ACK wire codec 和资源协商。Endpoint 不持有 TCP Transport，也不执行 TCP fd 读写。
+`Socket::_transport` 始终指向最上层的 `AdapterTransport`。它组合一个默认 `TcpTransport` 和至多一个独立的 `RdmaTransport`、`UrmaTransport` 或 `UBShmTransport`，并决定当前数据走哪个 Transport。`HandshakeSession` 驱动一次升级尝试的公共步骤；具体协议 adapter 通过回调完成 Hello/ACK wire codec 和资源协商。Endpoint 不持有 TCP Transport，也不执行 TCP fd 读写。
 
 ## 4.1 选定架构：Handshake 位于 Transport 层
 
@@ -151,11 +152,11 @@ flowchart TB
 
 ```mermaid
 flowchart TB
-    Socket["Socket"] --> T["RdmaTransport / UrmaTransport / UBShmTransport"]
-    T -. "继承" .-> UT["AdapterTransport"]
+    Socket["Socket"] --> UT["AdapterTransport\n顶层 Transport"]
     UT --> TCP["TcpTransport\n默认控制面与 TCP 数据面"]
     UT --> HS["HandshakeSession\n连接协商 / 版本 / ACK / fallback"]
     HS --> IO["SocketHandshakeIO"]
+    UT --> T["RdmaTransport / UrmaTransport / UBShmTransport\n独立 Transport"]
     T --> R["RdmaEndpoint\n仅高速数据面"]
     T --> U["UrmaEndpoint\n仅高速数据面"]
     T --> B["UBShmEndpoint\n仅高速数据面"]
@@ -166,7 +167,7 @@ flowchart TB
     HS -->|"ESTABLISHED"| T
 ```
 
-在该架构中，Endpoint 不再执行 TCP fd 读写、magic 判断、握手 bthread 或 TCP fallback。它只向 Transport 提供资源准备、Hello payload、远端参数应用和数据面操作。
+RDMA、URMA、UBSHM 仍然是完整的 `Transport` 实现，负责各自的高速发送、等待、事件派发和消息调度；它们不再继承 `AdapterTransport`。在该架构中，Endpoint 不再执行 TCP fd 读写、magic 判断、握手 bthread 或 TCP fallback，只向对应 Transport 提供资源准备、远端参数应用和数据面操作。
 
 ## 4.2 连接升级时序
 
@@ -527,20 +528,23 @@ UBSHM 是最适合优先迁移的实现，因为它只有固定长度 v2 协议
 不建议让 `RdmaEndpoint`、`UrmaEndpoint`、`UBShmEndpoint` 继承一个包含大量虚函数的“大 Endpoint 基类”。握手组件组合在 Transport 层，Endpoint 只暴露资源接口：
 
 ```cpp
-class RdmaTransport : public AdapterTransport {
+class AdapterTransport : public Transport {
     handshake::HandshakeSession _handshake;
+    std::unique_ptr<TcpTransport> _tcp_transport;
+    std::unique_ptr<Transport> _high_speed_transport;
+};
+
+class RdmaTransport : public Transport {
     RdmaEndpoint* _endpoint;
     // 每次升级尝试创建一个 RdmaHandshakeAdapter。
 };
 
-class UrmaTransport : public AdapterTransport {
-    handshake::HandshakeSession _handshake;
+class UrmaTransport : public Transport {
     UrmaEndpoint* _endpoint;
     // 每次升级尝试创建一个 UrmaHandshakeAdapter。
 };
 
-class UBShmTransport : public AdapterTransport {
-    handshake::HandshakeSession _handshake;
+class UBShmTransport : public Transport {
     UBShmEndpoint* _endpoint;
     // 每次升级尝试创建一个 UBShmHandshakeAdapter。
 };
@@ -559,7 +563,7 @@ Endpoint 仍然拥有：
 - data path；
 - transport-specific error handling。
 
-`AdapterTransport`/具体 Transport 拥有 TCP 路由、握手阶段、protocol callback 和 Endpoint 生命周期；公共 driver 不直接依赖 Endpoint 类型。
+`AdapterTransport` 拥有 TCP 路由、公共握手阶段和 active Transport 选择；具体高速 Transport 拥有 protocol callback 和 Endpoint 生命周期。公共 driver 不直接依赖 Endpoint 类型。
 
 ## 9. 兼容性和安全约束
 
@@ -722,6 +726,7 @@ classDiagram
     class AdapterTransport {
         -HandshakeSession handshake
         -TcpTransport tcp_transport
+        -Transport high_speed_transport
         +CutFromIOBuf()
         +CutFromIOBufList()
         +WaitEpollOut()
@@ -739,14 +744,19 @@ classDiagram
     }
     class RdmaTransport
     class RdmaHandshakeAdapter
+    class UrmaTransport
     class UBShmTransport
     class HighSpeedEndpoint
 
     Transport <|-- TcpTransport
     Transport <|-- AdapterTransport
-    AdapterTransport <|-- RdmaTransport
-    AdapterTransport <|-- UBShmTransport
+    Transport <|-- RdmaTransport
+    Transport <|-- UrmaTransport
+    Transport <|-- UBShmTransport
     AdapterTransport *-- TcpTransport
+    AdapterTransport *-- RdmaTransport
+    AdapterTransport *-- UrmaTransport
+    AdapterTransport *-- UBShmTransport
     AdapterTransport *-- HandshakeSession
     HandshakeSession *-- SocketHandshakeIO
     RdmaTransport --> RdmaHandshakeAdapter
@@ -754,7 +764,7 @@ classDiagram
     UBShmTransport --> HighSpeedEndpoint
 ```
 
-`AdapterTransport` 是 TCP-first 的公共路由层：`UNINITIALIZED/NEGOTIATING/FALLBACK_TCP` 都走 `TcpTransport`，仅当 `HandshakeSession` release 发布 `ESTABLISHED` 后才调用高速 Endpoint 的发送与等待钩子。成功升级后的 TCP 控制连接只允许 EOF，不再接受应用数据。
+`AdapterTransport` 是安装在 `Socket` 上的最上层 TCP-first Transport：`UNINITIALIZED/NEGOTIATING/FALLBACK_TCP` 都委托给 `TcpTransport`，仅当 `HandshakeSession` release 发布 `ESTABLISHED` 后才委托给所选的 RDMA/URMA/UBSHM Transport。成功升级后的 TCP 控制连接只允许 EOF，不再接受应用数据。
 
 `HandshakeSession::RunClient/RunServer` 统一执行资源准备、Hello 收发、远端参数协商、ACK 收发以及 established/fallback/failed 发布。RDMA/UBSHM 仅通过 callback 提供 wire codec 和资源操作；RDMA server 的 `STEP_NEED_MORE` 仍由 bRPC 标准 parser 增量驱动，UBSHM server 使用同一驱动的 blocking 模式。
 
@@ -762,11 +772,11 @@ classDiagram
 
 | 项目 | 状态 | 说明 |
 |---|---|---|
-| TCP-first 路由 | 已实现 | RDMA/UBSHM 共同继承 `AdapterTransport`，不再各自持有 `TcpTransport` |
+| TCP-first 路由 | 已实现 | `Socket` 持有顶层 `AdapterTransport`；其组合 `TcpTransport` 和一个独立高速 `Transport` |
 | 公共握手处理 | 已实现 | `RunClient/RunServer` 统一 Hello、资源协商、ACK、fallback 和错误流程 |
 | RDMA client/server | 已迁移 | wire adapter、fallback server 和 v3 proto 已全部迁至 `src/brpc`；server 保留 #3350 的标准增量解析流程 |
 | UBSHM client/server | 已迁移公共驱动 | server 当前使用 blocking 模式；后续只需把输入方式迁移到标准 parser |
-| URMA | 待迁移 | origin/master 暂无受版本控制的 URMA Transport；合入后实现 `AdapterTransport` 的数据面钩子并复用 `HandshakeSession` |
+| URMA | 待迁移 | origin/master 暂无受版本控制的 URMA Transport；合入后保留独立 `UrmaTransport`，由顶层 `AdapterTransport` 组合并复用 `HandshakeSession` |
 | RDMA Protocol adapter | 已实现 | `RdmaHandshakeAdapter` 显式接收 enabled 状态，不再读取 Transport/Socket 私有状态 |
 | 通用 FrameCodec | 待实现 | 当前保留 RDMA 已验证的 v2/v3 framing，后续与 URMA/UBSHM 一起抽取 |
 
diff --git a/src/brpc/adapter_transport.cpp b/src/brpc/adapter_transport.cpp
index d9a245850c..e952b0c9de 100644
--- a/src/brpc/adapter_transport.cpp
+++ b/src/brpc/adapter_transport.cpp
@@ -22,50 +22,127 @@
 #include <unistd.h>
 
 #include "brpc/input_messenger.h"
+#include "brpc/rdma_transport.h"
 #include "brpc/tcp_transport.h"
+#include "brpc/ubshm_transport.h"
 
 namespace brpc {
 
-void AdapterTransport::InitAdapterTransport(
-    Socket* socket, const SocketOptions& options,
-    const OnEdgeTrigger& default_on_edge) {
+AdapterTransport::~AdapterTransport() = default;
+
+AdapterTransport* AdapterTransport::Get(Socket* socket) {
+    CHECK(socket != NULL);
+    return static_cast<AdapterTransport*>(socket->_transport.get());
+}
+
+const AdapterTransport* AdapterTransport::Get(const Socket* socket) {
+    CHECK(socket != NULL);
+    return static_cast<const AdapterTransport*>(socket->_transport.get());
+}
+
+void AdapterTransport::Init(Socket* socket, const SocketOptions& options) {
+    CHECK_EQ(_mode, options.socket_mode);
     _socket = socket;
     _default_connect = options.app_connect;
     _on_edge_trigger = options.on_edge_triggered_events;
     if (options.need_on_edge_trigger && _on_edge_trigger == NULL) {
-        _on_edge_trigger = default_on_edge;
+        if (_mode == SOCKET_MODE_TCP) {
+            _on_edge_trigger = InputMessenger::OnNewMessages;
+#if BRPC_WITH_RDMA
+        } else if (_mode == SOCKET_MODE_RDMA &&
+                   options.user != static_cast<SocketUser*>(
+                       get_client_side_messenger())) {
+            // RDMA server handshake is parsed by InputMessenger.
+            _on_edge_trigger = InputMessenger::OnNewMessages;
+#endif
+        } else {
+            _on_edge_trigger = OnNewDataFromTcp;
+        }
     }
     _handshake.Reset(socket);
-    _tcp_transport = std::make_shared<TcpTransport>();
+    _tcp_transport.reset(new TcpTransport);
     _tcp_transport->Init(socket, options);
+
+    switch (_mode) {
+#if BRPC_WITH_RDMA
+    case SOCKET_MODE_RDMA:
+        _high_speed_transport.reset(new RdmaTransport);
+        break;
+#endif
+#if BRPC_WITH_UBRING
+    case SOCKET_MODE_UBRING:
+        _high_speed_transport.reset(new UBShmTransport);
+        break;
+#endif
+    default:
+        break;
+    }
+    if (_high_speed_transport) {
+        _high_speed_transport->Init(socket, options);
+    }
 }
 
-void AdapterTransport::ResetAdapterTransport() {
+void AdapterTransport::Release() {
+    if (_high_speed_transport) {
+        _high_speed_transport->Release();
+    }
+    _tcp_transport->Release();
+}
+
+int AdapterTransport::Reset(int32_t expected_nref) {
+    if (_high_speed_transport) {
+        _high_speed_transport->Reset(expected_nref);
+    }
+    _tcp_transport->Reset(expected_nref);
     _handshake.Reset(_socket);
+    return 0;
 }
 
-int AdapterTransport::CutFromIOBuf(butil::IOBuf* buf) {
-    if (_handshake.phase() == handshake::ESTABLISHED) {
-        butil::IOBuf* data[1] = {buf};
-        return CutFromHighSpeedIOBufList(data, 1);
+std::shared_ptr<AppConnect> AdapterTransport::Connect() {
+    if (_high_speed_transport) {
+        return _high_speed_transport->Connect();
     }
-    return _tcp_transport->CutFromIOBuf(buf);
+    return _tcp_transport->Connect();
+}
+
+Transport* AdapterTransport::ActiveTransport() const {
+    if (_high_speed_transport &&
+        _handshake.phase() == handshake::ESTABLISHED) {
+        return _high_speed_transport.get();
+    }
+    return _tcp_transport.get();
+}
+
+int AdapterTransport::CutFromIOBuf(butil::IOBuf* buf) {
+    return ActiveTransport()->CutFromIOBuf(buf);
 }
 
 ssize_t AdapterTransport::CutFromIOBufList(
     butil::IOBuf** buf, size_t ndata) {
-    if (_handshake.phase() == handshake::ESTABLISHED) {
-        return CutFromHighSpeedIOBufList(buf, ndata);
-    }
-    return _tcp_transport->CutFromIOBufList(buf, ndata);
+    return ActiveTransport()->CutFromIOBufList(buf, ndata);
 }
 
 int AdapterTransport::WaitEpollOut(butil::atomic<int>* epollout_butex,
                                     bool pollin, timespec duetime) {
-    if (_handshake.phase() == handshake::ESTABLISHED) {
-        return WaitHighSpeedEpollOut(epollout_butex, pollin, duetime);
+    return ActiveTransport()->WaitEpollOut(
+        epollout_butex, pollin, duetime);
+}
+
+void AdapterTransport::ProcessEvent(bthread_attr_t attr) {
+    ActiveTransport()->ProcessEvent(attr);
+}
+
+void AdapterTransport::QueueMessage(InputMessageClosure& input_msg,
+                                    int* num_bthread_created,
+                                    bool last_msg) {
+    ActiveTransport()->QueueMessage(
+        input_msg, num_bthread_created, last_msg);
+}
+
+void AdapterTransport::Debug(std::ostream& os) {
+    if (_high_speed_transport) {
+        _high_speed_transport->Debug(os);
     }
-    return _tcp_transport->WaitEpollOut(epollout_butex, pollin, duetime);
 }
 
 void AdapterTransport::FallbackToTcp() {
@@ -74,6 +151,45 @@ void AdapterTransport::FallbackToTcp() {
     });
 }
 
+void AdapterTransport::SetHighSpeedAvailable(bool available) {
+    if (!_high_speed_transport) {
+        return;
+    }
+    switch (_mode) {
+#if BRPC_WITH_RDMA
+    case SOCKET_MODE_RDMA:
+        static_cast<RdmaTransport*>(_high_speed_transport.get())
+            ->SetHighSpeedAvailable(available);
+        break;
+#endif
+#if BRPC_WITH_UBRING
+    case SOCKET_MODE_UBRING:
+        static_cast<UBShmTransport*>(_high_speed_transport.get())
+            ->SetHighSpeedAvailable(available);
+        break;
+#endif
+    default:
+        break;
+    }
+}
+
+void AdapterTransport::StartServerHandshake() {
+    if (!_high_speed_transport) {
+        return;
+    }
+    switch (_mode) {
+#if BRPC_WITH_UBRING
+    case SOCKET_MODE_UBRING:
+        static_cast<UBShmTransport*>(_high_speed_transport.get())
+            ->StartServerHandshake();
+        break;
+#endif
+    default:
+        // RDMA uses the standard InputMessenger protocol parser.
+        break;
+    }
+}
+
 void AdapterTransport::OnNewDataFromTcp(Socket* socket) {
     static_cast<AdapterTransport*>(socket->_transport.get())->ProcessTcpEvent();
 }
@@ -83,7 +199,7 @@ void AdapterTransport::ProcessTcpEvent() {
     while (true) {
         const int phase = _handshake.phase();
         if (phase == handshake::UNINITIALIZED) {
-            if (!_socket->CreatedByConnect()) {
+            if (!_socket->CreatedByConnect() && _high_speed_transport) {
                 StartServerHandshake();
                 if (_handshake.phase() != handshake::UNINITIALIZED) {
                     continue;
diff --git a/src/brpc/adapter_transport.h b/src/brpc/adapter_transport.h
index 6819b9b079..25cbb666c0 100644
--- a/src/brpc/adapter_transport.h
+++ b/src/brpc/adapter_transport.h
@@ -20,55 +20,65 @@
 
 #include <memory>
 
+#include "brpc/socket_mode.h"
 #include "brpc/transport.h"
 #include "brpc/transport_handshake.h"
 
 namespace brpc {
 
 class TcpTransport;
+class RdmaTransport;
+class UBShmTransport;
 
-// A TCP-first transport that may switch its data plane after a successful
+// The top-level Transport installed in Socket. It starts on TcpTransport and
+// may switch to an independent RDMA/URMA/UBSHM Transport after a successful
 // handshake. TCP remains usable before negotiation and after fallback.
 class AdapterTransport : public Transport {
+    friend class TransportFactory;
+    friend class RdmaTransport;
+    friend class UBShmTransport;
 public:
+    void Init(Socket* socket, const SocketOptions& options) override;
+    void Release() override;
+    int Reset(int32_t expected_nref) override;
+    std::shared_ptr<AppConnect> Connect() override;
     int CutFromIOBuf(butil::IOBuf* buf) override;
     ssize_t CutFromIOBufList(butil::IOBuf** buf, size_t ndata) override;
     int WaitEpollOut(butil::atomic<int>* epollout_butex,
                      bool pollin, timespec duetime) override;
+    void ProcessEvent(bthread_attr_t attr) override;
+    void QueueMessage(InputMessageClosure& input_msg,
+                      int* num_bthread_created, bool last_msg) override;
+    void Debug(std::ostream& os) override;
 
     int handshake_phase() const { return _handshake.phase(); }
     int handshake_version() const { return _handshake.protocol_version(); }
+    Transport* high_speed_transport() const {
+        return _high_speed_transport.get();
+    }
 
-    static void OnNewDataFromTcp(Socket* socket);
+    static AdapterTransport* Get(Socket* socket);
+    static const AdapterTransport* Get(const Socket* socket);
 
-protected:
-    AdapterTransport() = default;
-    ~AdapterTransport() override = default;
+    static void OnNewDataFromTcp(Socket* socket);
 
-    void InitAdapterTransport(Socket* socket, const SocketOptions& options,
-                              const OnEdgeTrigger& default_on_edge);
-    void ResetAdapterTransport();
+private:
+    explicit AdapterTransport(SocketMode mode) : _mode(mode) {}
+    ~AdapterTransport() override;
 
+    Transport* ActiveTransport() const;
+    handshake::HandshakeSession* handshake_session() { return &_handshake; }
+    void SetHighSpeedAvailable(bool available);
+    void StartServerHandshake();
     void FallbackToTcp();
     void TryReadOnTcp();
-
-    virtual void SetHighSpeedAvailable(bool available) = 0;
-    virtual ssize_t CutFromHighSpeedIOBufList(
-        butil::IOBuf** buf, size_t ndata) = 0;
-    virtual int WaitHighSpeedEpollOut(butil::atomic<int>* epollout_butex,
-                                      bool pollin, timespec duetime) = 0;
-
-    // Called only for an accepted socket whose handshake phase is still
-    // UNINITIALIZED. Protocols parsed by InputMessenger can leave this as a
-    // no-op and install InputMessenger::OnNewMessages on server sockets.
-    virtual void StartServerHandshake() {}
-
-    handshake::HandshakeSession _handshake;
-    std::shared_ptr<TcpTransport> _tcp_transport;
-
-private:
     void ProcessTcpEvent();
     void CheckUnexpectedTcpData();
+
+    SocketMode _mode;
+    handshake::HandshakeSession _handshake;
+    std::unique_ptr<TcpTransport> _tcp_transport;
+    std::unique_ptr<Transport> _high_speed_transport;
 };
 
 }  // namespace brpc
diff --git a/src/brpc/rdma/rdma_endpoint.cpp b/src/brpc/rdma/rdma_endpoint.cpp
index c37402514f..c5c5f2ee93 100644
--- a/src/brpc/rdma/rdma_endpoint.cpp
+++ b/src/brpc/rdma/rdma_endpoint.cpp
@@ -1041,7 +1041,7 @@ void RdmaEndpoint::PollCq(Socket* m) {
     if (Socket::Address(ep->_socket->id(), &s) < 0) {
         return;
     }
-    auto* rdma_transport = static_cast<RdmaTransport*>(s->_transport.get());
+    RdmaTransport* rdma_transport = RdmaTransport::Get(s.get());
     CHECK(ep == rdma_transport->_rdma_ep);
 
     bool send = false;
diff --git a/src/brpc/rdma_transport.cpp b/src/brpc/rdma_transport.cpp
index ff8ba3e43e..f651993a26 100644
--- a/src/brpc/rdma_transport.cpp
+++ b/src/brpc/rdma_transport.cpp
@@ -19,6 +19,7 @@
 
 #include "brpc/rdma_transport.h"
 #include "butil/sys_byteorder.h"
+#include "brpc/adapter_transport.h"
 #include "brpc/event_dispatcher.h"
 #include "brpc/input_messenger.h"
 #include "brpc/rdma/rdma_endpoint.h"
@@ -40,8 +41,7 @@ DECLARE_bool(rdma_trace_verbose);
 void RdmaConnect::StartConnect(const Socket* socket,
                                void (*done)(int err, void* data),
                                void* data) {
-    RdmaTransport* transport =
-        static_cast<RdmaTransport*>(socket->_transport.get());
+    RdmaTransport* transport = RdmaTransport::Get(socket);
     CHECK(transport->_rdma_ep != NULL);
     SocketUniquePtr ptr;
     if (Socket::Address(socket->id(), &ptr) != 0) {
@@ -75,6 +75,33 @@ void RdmaConnect::Run() {
 
 }  // namespace rdma
 
+RdmaTransport* RdmaTransport::Get(const Socket* socket) {
+    const AdapterTransport* adapter = AdapterTransport::Get(socket);
+    Transport* transport = adapter->high_speed_transport();
+    CHECK(transport != NULL);
+    return static_cast<RdmaTransport*>(transport);
+}
+
+AdapterTransport* RdmaTransport::adapter_transport() const {
+    return AdapterTransport::Get(_socket);
+}
+
+handshake::HandshakeSession* RdmaTransport::handshake_session() const {
+    return adapter_transport()->handshake_session();
+}
+
+int RdmaTransport::handshake_phase() const {
+    return adapter_transport()->handshake_phase();
+}
+
+int RdmaTransport::handshake_version() const {
+    return adapter_transport()->handshake_version();
+}
+
+void RdmaTransport::FallbackToTcp() {
+    adapter_transport()->FallbackToTcp();
+}
+
 void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
     RdmaTransport* transport = static_cast<RdmaTransport*>(arg);
     rdma::RdmaEndpoint* ep = transport->_rdma_ep;
@@ -87,9 +114,10 @@ void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
 
     std::unique_ptr<rdma::RdmaHandshakeAdapter> protocol =
         rdma::CreateClientHandshakeAdapter(
-            ep, transport->_handshake.io());
+            ep, transport->handshake_session()->io());
     CHECK(protocol != NULL);
-    transport->_handshake.set_protocol_version(protocol->ProtocolVersion());
+    transport->handshake_session()->set_protocol_version(
+        protocol->ProtocolVersion());
     rdma::ParsedHello remote{};
 
     handshake::ClientHandshakeCallbacks callbacks{};
@@ -144,7 +172,7 @@ void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
     callbacks.send_ack = [&](bool enabled) {
         const uint32_t flags_be = butil::HostToNet32(
             enabled ? rdma::HELLO_ACK_RDMA_OK : 0);
-        if (transport->_handshake.io()->WriteAll(
+        if (transport->handshake_session()->io()->WriteAll(
                 &flags_be, rdma::HELLO_ACK_LEN) == 0) {
             return handshake::STEP_OK;
         }
@@ -163,7 +191,7 @@ void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
     callbacks.on_failed = []() {};
 
     const handshake::StepResult result =
-        transport->_handshake.RunClient(callbacks);
+        transport->handshake_session()->RunClient(callbacks);
     if (result == handshake::STEP_OK) {
         LOG_IF(INFO, rdma::FLAGS_rdma_trace_verbose)
             << "Client handshake ends (use rdma v"
@@ -179,8 +207,7 @@ void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
 
 ParseResult RdmaTransport::ExecuteServerHandshake(butil::IOBuf* source,
                                                    Socket* socket) {
-    RdmaTransport* transport =
-        static_cast<RdmaTransport*>(socket->_transport.get());
+    RdmaTransport* transport = RdmaTransport::Get(socket);
     rdma::RdmaEndpoint* ep = transport->_rdma_ep;
     CHECK(ep != NULL);
 
@@ -198,11 +225,12 @@ ParseResult RdmaTransport::ExecuteServerHandshake(butil::IOBuf* source,
         uint8_t magic[rdma::HELLO_MAGIC_LEN];
         CHECK_EQ(source->copy_to(magic, sizeof(magic)), sizeof(magic));
         protocol = rdma::CreateServerHandshakeAdapterByMagic(
-            ep, transport->_handshake.io(), source, magic);
+            ep, transport->handshake_session()->io(), source, magic);
         if (protocol == NULL) {
             return handshake::STEP_NOT_MINE;
         }
-        transport->_handshake.set_protocol_version(protocol->ProtocolVersion());
+        transport->handshake_session()->set_protocol_version(
+            protocol->ProtocolVersion());
         const rdma::RemoteHelloResult result =
             protocol->ReceiveAndParseRemoteHello(&remote);
         if (result == rdma::RemoteHelloResult::NEED_MORE) {
@@ -266,9 +294,9 @@ ParseResult RdmaTransport::ExecuteServerHandshake(butil::IOBuf* source,
     callbacks.on_failed = []() {};
 
     const handshake::StepResult result =
-        transport->_handshake.RunServer(callbacks);
+        transport->handshake_session()->RunServer(callbacks);
     if (result == handshake::STEP_NEED_MORE) {
-        if (transport->_handshake.phase() == S_ACK_WAIT &&
+        if (transport->handshake_phase() == S_ACK_WAIT &&
             socket->parsing_context() == NULL) {
             socket->reset_parsing_context(
                 rdma::ServerHandshakeContext::Create());
@@ -284,33 +312,17 @@ ParseResult RdmaTransport::ExecuteServerHandshake(butil::IOBuf* source,
 
 void RdmaTransport::Init(Socket *socket, const SocketOptions &options) {
     CHECK(_rdma_ep == NULL);
-    if (options.socket_mode == SOCKET_MODE_RDMA) {
-        _rdma_ep = new(std::nothrow)rdma::RdmaEndpoint(socket);
-        if (!_rdma_ep) {
-            const int saved_errno = errno;
-            PLOG(ERROR) << "Fail to create RdmaEndpoint";
-            socket->SetFailed(
-                saved_errno, "Fail to create RdmaEndpoint: %s", berror(saved_errno));
-        }
-        _rdma_state = RDMA_UNKNOWN;
-    } else {
-        _rdma_state = RDMA_OFF;
-        socket->_socket_mode = SOCKET_MODE_TCP;
-    }
-    OnEdgeTrigger default_on_edge;
-    if (options.need_on_edge_trigger) {
-        // Server-side RDMA sockets drive the handshake through the standard
-        // InputMessenger path (ParseRdmaHandshake), so they use OnNewMessages
-        // just like TCP sockets. Only client-side sockets, whose handshake
-        // ProcessHandshakeAtClient is an active blocking bthread relying on
-        // HandshakeSession being woken by OnNewDataFromTcp.
-        if (options.user == static_cast<SocketUser*>(get_client_side_messenger())) {
-            default_on_edge = AdapterTransport::OnNewDataFromTcp;
-        } else {
-            default_on_edge = InputMessenger::OnNewMessages;
-        }
+    _socket = socket;
+    _default_connect = options.app_connect;
+    _on_edge_trigger = NULL;
+    _rdma_ep = new(std::nothrow)rdma::RdmaEndpoint(socket);
+    if (!_rdma_ep) {
+        const int saved_errno = errno;
+        PLOG(ERROR) << "Fail to create RdmaEndpoint";
+        socket->SetFailed(
+            saved_errno, "Fail to create RdmaEndpoint: %s", berror(saved_errno));
     }
-    InitAdapterTransport(socket, options, default_on_edge);
+    _rdma_state = RDMA_UNKNOWN;
 }
 
 void RdmaTransport::Release() {
@@ -326,7 +338,6 @@ int RdmaTransport::Reset(int32_t expected_nref) {
         _rdma_ep->Reset();
         _rdma_state = RDMA_UNKNOWN;
     }
-    ResetAdapterTransport();
     return 0;
 }
 
@@ -341,13 +352,18 @@ void RdmaTransport::SetHighSpeedAvailable(bool available) {
     _rdma_state = available ? RDMA_ON : RDMA_OFF;
 }
 
-ssize_t RdmaTransport::CutFromHighSpeedIOBufList(
+int RdmaTransport::CutFromIOBuf(butil::IOBuf* buf) {
+    butil::IOBuf* data[1] = {buf};
+    return static_cast<int>(CutFromIOBufList(data, 1));
+}
+
+ssize_t RdmaTransport::CutFromIOBufList(
     butil::IOBuf** buf, size_t ndata) {
     CHECK(_rdma_ep != NULL);
     return _rdma_ep->CutFromIOBufList(buf, ndata);
 }
 
-int RdmaTransport::WaitHighSpeedEpollOut(
+int RdmaTransport::WaitEpollOut(
     butil::atomic<int>* epollout_butex, bool, timespec duetime) {
     const int expected_val = epollout_butex->load(butil::memory_order_acquire);
     CHECK(_rdma_ep != NULL);
@@ -427,7 +443,7 @@ void RdmaTransport::Debug(std::ostream &os) {
         _rdma_ep->DebugInfo(os);
     }
     const char* state = "UNKNOWN";
-    switch (_handshake.phase(butil::memory_order_relaxed)) {
+    switch (handshake_session()->phase(butil::memory_order_relaxed)) {
     case UNINIT: state = "UNINIT"; break;
     case C_ALLOC_QPCQ: state = "C_ALLOC_QPCQ"; break;
     case C_HELLO_SEND: state = "C_HELLO_SEND"; break;
diff --git a/src/brpc/rdma_transport.h b/src/brpc/rdma_transport.h
index 8dea37b6ae..41a5155741 100644
--- a/src/brpc/rdma_transport.h
+++ b/src/brpc/rdma_transport.h
@@ -21,11 +21,14 @@
 #if BRPC_WITH_RDMA
 #include "brpc/socket.h"
 #include "brpc/channel.h"
-#include "brpc/adapter_transport.h"
+#include "brpc/transport.h"
+#include "brpc/transport_handshake.h"
 
 namespace brpc {
-class RdmaTransport : public AdapterTransport {
+class AdapterTransport;
+class RdmaTransport : public Transport {
     friend class TransportFactory;
+    friend class AdapterTransport;
     friend class rdma::RdmaEndpoint;
     friend class rdma::RdmaConnect;
 public:
@@ -50,6 +53,10 @@ class RdmaTransport : public AdapterTransport {
     void Release() override;
     int Reset(int32_t expected_nref) override;
     std::shared_ptr<AppConnect> Connect() override;
+    int CutFromIOBuf(butil::IOBuf* buf) override;
+    ssize_t CutFromIOBufList(butil::IOBuf** buf, size_t ndata) override;
+    int WaitEpollOut(butil::atomic<int>* epollout_butex,
+                     bool pollin, timespec duetime) override;
     void ProcessEvent(bthread_attr_t attr) override;
     void QueueMessage(InputMessageClosure& inputMsg, int* num_bthread_created, bool last_msg) override;
     void Debug(std::ostream &os) override;
@@ -57,7 +64,13 @@ class RdmaTransport : public AdapterTransport {
         CHECK(_rdma_ep != NULL);
         return _rdma_ep;
     }
+    static RdmaTransport* Get(const Socket* socket);
+    static RdmaTransport* Get(const SocketUniquePtr& socket) {
+        return Get(socket.get());
+    }
     static int ContextInitOrDie(bool serverOrNot, const void* _options);
+    int handshake_phase() const;
+    int handshake_version() const;
 
     // TCP control-plane callbacks. The endpoint is intentionally absent from
     // these entry points and only participates through resource operations.
@@ -65,11 +78,10 @@ class RdmaTransport : public AdapterTransport {
     static ParseResult ExecuteServerHandshake(butil::IOBuf* source,
                                               Socket* socket);
 private:
-    void SetHighSpeedAvailable(bool available) override;
-    ssize_t CutFromHighSpeedIOBufList(
-        butil::IOBuf** buf, size_t ndata) override;
-    int WaitHighSpeedEpollOut(butil::atomic<int>* epollout_butex,
-                              bool pollin, timespec duetime) override;
+    AdapterTransport* adapter_transport() const;
+    handshake::HandshakeSession* handshake_session() const;
+    void FallbackToTcp();
+    void SetHighSpeedAvailable(bool available);
 
     static bool OptionsAvailableForRdma(const ChannelOptions* opt);
     static bool OptionsAvailableOverRdma(const ServerOptions* opt);
diff --git a/src/brpc/socket.h b/src/brpc/socket.h
index cf5086897b..70904d98d4 100644
--- a/src/brpc/socket.h
+++ b/src/brpc/socket.h
@@ -945,8 +945,10 @@ friend class TransportFactory;
     SSL* _ssl_session;               // owner
     std::shared_ptr<SocketSSLContext> _ssl_ctx;
 
-    // Should use SOCKET_MODE_RDMA or SOCKET_MODE_TCP or Other, default is SOCKET_MODE_TCP Transport
+    // Requested provider: SOCKET_MODE_TCP, SOCKET_MODE_RDMA or another mode.
     SocketMode _socket_mode;
+    // The top-level AdapterTransport, which selects TCP or the requested
+    // accelerated Transport.
     std::unique_ptr<Transport> _transport;
 
     // Pass from controller, for progressive reading.
diff --git a/src/brpc/transport_factory.cpp b/src/brpc/transport_factory.cpp
index 36fdaaed05..3355e0764d 100644
--- a/src/brpc/transport_factory.cpp
+++ b/src/brpc/transport_factory.cpp
@@ -16,7 +16,7 @@
 // under the License.
 
 #include "brpc/transport_factory.h"
-#include "brpc/tcp_transport.h"
+#include "brpc/adapter_transport.h"
 #include "brpc/rdma_transport.h"
 #include "brpc/ubshm_transport.h"
 
@@ -43,16 +43,16 @@ int TransportFactory::ContextInitOrDie(SocketMode mode, bool serverOrNot, const
 
 std::unique_ptr<Transport> TransportFactory::CreateTransport(SocketMode mode) {
     if (mode == SOCKET_MODE_TCP) {
-        return std::unique_ptr<TcpTransport>(new TcpTransport());
+        return std::unique_ptr<Transport>(new AdapterTransport(mode));
     }
 #if BRPC_WITH_RDMA
     else if (mode == SOCKET_MODE_RDMA) {
-        return std::unique_ptr<RdmaTransport>(new RdmaTransport());
+        return std::unique_ptr<Transport>(new AdapterTransport(mode));
     }
 #endif
 #if BRPC_WITH_UBRING
     else if (mode == SOCKET_MODE_UBRING) {
-        return std::unique_ptr<UBShmTransport>(new UBShmTransport());
+        return std::unique_ptr<Transport>(new AdapterTransport(mode));
     }
 #endif
     else {
@@ -60,4 +60,4 @@ std::unique_ptr<Transport> TransportFactory::CreateTransport(SocketMode mode) {
         return nullptr;
     }
 }
-} // namespace brpc
\ No newline at end of file
+} // namespace brpc
diff --git a/src/brpc/transport_factory.h b/src/brpc/transport_factory.h
index d933a130e1..add249c438 100644
--- a/src/brpc/transport_factory.h
+++ b/src/brpc/transport_factory.h
@@ -22,7 +22,8 @@
 #include "brpc/transport.h"
 
 namespace brpc {
-// TransportFactory to create transport instance with socket_mode {TCP, RDMA}
+// Creates the top-level AdapterTransport for all socket modes. The adapter
+// selects TcpTransport or a concrete accelerated Transport internally.
 class TransportFactory {
 public:
     static int ContextInitOrDie(SocketMode mode, bool serverOrNot, const void* _options);
@@ -31,4 +32,4 @@ class TransportFactory {
 };
 } // namespace brpc
 
-#endif //BRPC_TRANSPORT_FACTORY_H
\ No newline at end of file
+#endif //BRPC_TRANSPORT_FACTORY_H
diff --git a/src/brpc/ubshm/ub_endpoint.cpp b/src/brpc/ubshm/ub_endpoint.cpp
index 0b04a38b50..4c194d7d18 100644
--- a/src/brpc/ubshm/ub_endpoint.cpp
+++ b/src/brpc/ubshm/ub_endpoint.cpp
@@ -144,7 +144,7 @@ void UBShmEndpoint::Reset() {
 void UBConnect::StartConnect(const Socket* socket,
                                void (*done)(int err, void* data),
                                void* data) {
-    auto* ub_transport = static_cast<UBShmTransport*>(socket->_transport.get());
+    UBShmTransport* ub_transport = UBShmTransport::Get(socket);
     CHECK(ub_transport->_ub_ep != NULL);
     SocketUniquePtr s;
     if (Socket::Address(socket->id(), &s) != 0) {
@@ -187,14 +187,14 @@ void UBShmTransport::StartServerHandshake() {
         return;
     }
     bthread_t tid;
-    _handshake.SetPhase(S_HELLO_WAIT);
+    handshake_session()->SetPhase(S_HELLO_WAIT);
     SocketUniquePtr socket;
     _socket->ReAddress(&socket);
     bthread_attr_t attr = BTHREAD_ATTR_NORMAL;
     bthread_attr_set_name(&attr, "UBProcessHandshakeAtServer");
     if (bthread_start_background(
             &tid, &attr, ProcessHandshakeAtServer, this) < 0) {
-        _handshake.SetPhase(UNINIT);
+        handshake_session()->SetPhase(UNINIT);
         LOG(FATAL) << "Fail to start handshake bthread";
     } else {
         socket.release();
@@ -247,7 +247,7 @@ void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
                SHM_MAX_NAME_BUFF_LEN);
         memcpy(data, MAGIC_STR, MAGIC_STR_LEN);
         local_msg.Serialize((char*)data + MAGIC_STR_LEN);
-        if (ub_transport->_handshake.io()->WriteAll(
+        if (ub_transport->handshake_session()->io()->WriteAll(
                 data, g_ub_hello_msg_len) == 0) {
             LOG_IF(INFO, FLAGS_ub_trace_verbose)
                 << "client handshake message : " << local_msg.toString();
@@ -262,7 +262,7 @@ void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
         return handshake::STEP_ERROR;
     };
     callbacks.receive_remote_hello = [&]() {
-        if (ub_transport->_handshake.io()->ReadExact(
+        if (ub_transport->handshake_session()->io()->ReadExact(
                 data, MAGIC_STR_LEN) < 0) {
             const int saved_errno = errno;
             s->SetFailed(saved_errno,
@@ -276,7 +276,7 @@ void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
                          s->description().c_str(), berror(EPROTO));
             return handshake::STEP_ERROR;
         }
-        if (ub_transport->_handshake.io()->ReadExact(
+        if (ub_transport->handshake_session()->io()->ReadExact(
                 data, HELLO_MSG_LEN_MIN - MAGIC_STR_LEN) < 0) {
             const int saved_errno = errno;
             s->SetFailed(saved_errno,
@@ -309,7 +309,8 @@ void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
     callbacks.send_ack = [&](bool enabled) {
         uint32_t* flags = (uint32_t*)data;
         *flags = butil::HostToNet32(enabled ? ACK_MSG_UB_OK : 0);
-        if (ub_transport->_handshake.io()->WriteAll(data, ACK_MSG_LEN) == 0) {
+        if (ub_transport->handshake_session()->io()->WriteAll(
+                data, ACK_MSG_LEN) == 0) {
             return handshake::STEP_OK;
         }
         const int saved_errno = errno;
@@ -327,7 +328,7 @@ void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
     callbacks.on_failed = []() {};
 
     const handshake::StepResult result =
-        ub_transport->_handshake.RunClient(callbacks);
+        ub_transport->handshake_session()->RunClient(callbacks);
     if (result == handshake::STEP_OK) {
         ep->_ub_ring->UbrUnlinkLocalShm();
         LOG_IF(INFO, FLAGS_ub_trace_verbose) 
@@ -360,7 +361,7 @@ void* UBShmTransport::ProcessHandshakeAtServer(void* arg) {
         S_ALLOC_SHM, 0, S_ACK_WAIT};
     callbacks.fallback_on_not_mine = true;
     callbacks.receive_remote_hello = [&]() {
-        if (ub_transport->_handshake.io()->ReadExact(
+        if (ub_transport->handshake_session()->io()->ReadExact(
                 data, MAGIC_STR_LEN) < 0) {
             const int saved_errno = errno;
             s->SetFailed(saved_errno,
@@ -372,7 +373,7 @@ void* UBShmTransport::ProcessHandshakeAtServer(void* arg) {
             s->_read_buf.append(data, MAGIC_STR_LEN);
             return handshake::STEP_NOT_MINE;
         }
-        if (ub_transport->_handshake.io()->ReadExact(
+        if (ub_transport->handshake_session()->io()->ReadExact(
                 data, g_ub_hello_msg_len - MAGIC_STR_LEN) < 0) {
             const int saved_errno = errno;
             s->SetFailed(saved_errno,
@@ -440,7 +441,7 @@ void* UBShmTransport::ProcessHandshakeAtServer(void* arg) {
         }
         memcpy(data, MAGIC_STR, MAGIC_STR_LEN);
         local_msg.Serialize((char*)data + MAGIC_STR_LEN);
-        if (ub_transport->_handshake.io()->WriteAll(
+        if (ub_transport->handshake_session()->io()->WriteAll(
                 data, g_ub_hello_msg_len) == 0) {
             return handshake::STEP_OK;
         }
@@ -451,7 +452,7 @@ void* UBShmTransport::ProcessHandshakeAtServer(void* arg) {
         return handshake::STEP_ERROR;
     };
     callbacks.receive_ack = [&]() {
-        if (ub_transport->_handshake.io()->ReadExact(
+        if (ub_transport->handshake_session()->io()->ReadExact(
                 data, ACK_MSG_LEN) < 0) {
             const int saved_errno = errno;
             s->SetFailed(saved_errno,
@@ -482,7 +483,7 @@ void* UBShmTransport::ProcessHandshakeAtServer(void* arg) {
     callbacks.on_failed = []() {};
 
     const handshake::StepResult result =
-        ub_transport->_handshake.RunServer(callbacks);
+        ub_transport->handshake_session()->RunServer(callbacks);
     if (result == handshake::STEP_OK) {
         ep->_ub_ring->UbrUnlinkLocalShm();
         LOG_IF(INFO, FLAGS_ub_trace_verbose)
@@ -654,7 +655,7 @@ void UBShmEndpoint::PollIn(UBShmEndpoint* ep, uint32_t ep_event) {
     if (Socket::Address(ep->_socket_id, &s) < 0) {
         return;
     }
-    auto* ub_transport = static_cast<UBShmTransport*>(s->_transport.get());
+    UBShmTransport* ub_transport = UBShmTransport::Get(s.get());
     CHECK(ep == ub_transport->_ub_ep);
 
     InputMessageClosure last_msg;
@@ -716,7 +717,7 @@ void UBShmEndpoint::PollOut(UBShmEndpoint* ep, uint32_t ep_event) {
     if (Socket::Address(ep->_socket_id, &s) < 0) {
         return;
     }
-    auto* ub_transport = static_cast<UBShmTransport*>(s->_transport.get());
+    UBShmTransport* ub_transport = UBShmTransport::Get(s.get());
     CHECK(ep == ub_transport->_ub_ep);
     if (ep->IsWritable()) {
         s->WakeAsEpollOut();
diff --git a/src/brpc/ubshm_transport.cpp b/src/brpc/ubshm_transport.cpp
index 8a09deabc1..7c3daac6bc 100644
--- a/src/brpc/ubshm_transport.cpp
+++ b/src/brpc/ubshm_transport.cpp
@@ -18,6 +18,7 @@
 #if BRPC_WITH_UBRING
 
 #include "brpc/ubshm_transport.h"
+#include "brpc/adapter_transport.h"
 #include "brpc/ubshm/ub_endpoint.h"
 #include "brpc/ubshm/ub_helper.h"
 
@@ -27,22 +28,50 @@ DECLARE_bool(usercode_in_pthread);
 
 extern SocketVarsCollector *g_vars;
 
+UBShmTransport* UBShmTransport::Get(const Socket* socket) {
+    const AdapterTransport* adapter = AdapterTransport::Get(socket);
+    Transport* transport = adapter->high_speed_transport();
+    CHECK(transport != NULL);
+    return static_cast<UBShmTransport*>(transport);
+}
+
+AdapterTransport* UBShmTransport::adapter_transport() const {
+    return AdapterTransport::Get(_socket);
+}
+
+handshake::HandshakeSession* UBShmTransport::handshake_session() const {
+    return adapter_transport()->handshake_session();
+}
+
+int UBShmTransport::handshake_phase() const {
+    return adapter_transport()->handshake_phase();
+}
+
+int UBShmTransport::handshake_version() const {
+    return adapter_transport()->handshake_version();
+}
+
+void UBShmTransport::FallbackToTcp() {
+    adapter_transport()->FallbackToTcp();
+}
+
+void UBShmTransport::TryReadOnTcp() {
+    adapter_transport()->TryReadOnTcp();
+}
+
 void UBShmTransport::Init(Socket *socket, const SocketOptions &options) {
     CHECK(_ub_ep == NULL);
-    if (options.socket_mode == SOCKET_MODE_UBRING) {
-        _ub_ep = new(std::nothrow)ubring::UBShmEndpoint(socket);
-        if (!_ub_ep) {
-            const int saved_errno = errno;
-            PLOG(ERROR) << "Fail to create UBShmEndpoint";
-            socket->SetFailed(
-                saved_errno, "Fail to create UBShmEndpoint: %s", berror(saved_errno));
-        }
-        _ub_state = UB_UNKNOWN;
-    } else {
-        _ub_state = UB_OFF;
-        socket->_socket_mode = SOCKET_MODE_TCP;
-    }
-    InitAdapterTransport(socket, options, AdapterTransport::OnNewDataFromTcp);
+    _socket = socket;
+    _default_connect = options.app_connect;
+    _on_edge_trigger = NULL;
+    _ub_ep = new(std::nothrow)ubring::UBShmEndpoint(socket);
+    if (!_ub_ep) {
+        const int saved_errno = errno;
+        PLOG(ERROR) << "Fail to create UBShmEndpoint";
+        socket->SetFailed(
+            saved_errno, "Fail to create UBShmEndpoint: %s", berror(saved_errno));
+    }
+    _ub_state = UB_UNKNOWN;
 }
 
 void UBShmTransport::Release() {
@@ -58,7 +87,6 @@ int UBShmTransport::Reset(int32_t expected_nref) {
         _ub_ep->Reset();
         _ub_state = UB_UNKNOWN;
     }
-    ResetAdapterTransport();
     return 0;
 }
 
@@ -73,13 +101,18 @@ void UBShmTransport::SetHighSpeedAvailable(bool available) {
     _ub_state = available ? UB_ON : UB_OFF;
 }
 
-ssize_t UBShmTransport::CutFromHighSpeedIOBufList(
+int UBShmTransport::CutFromIOBuf(butil::IOBuf* buf) {
+    butil::IOBuf* data[1] = {buf};
+    return static_cast<int>(CutFromIOBufList(data, 1));
+}
+
+ssize_t UBShmTransport::CutFromIOBufList(
     butil::IOBuf** buf, size_t ndata) {
     CHECK(_ub_ep != NULL);
     return _ub_ep->CutFromIOBufList(buf, ndata);
 }
 
-int UBShmTransport::WaitHighSpeedEpollOut(
+int UBShmTransport::WaitEpollOut(
     butil::atomic<int>* epollout_butex, bool pollin, timespec duetime) {
     const int expected_val = epollout_butex->load(butil::memory_order_acquire);
     CHECK(_ub_ep != NULL);
diff --git a/src/brpc/ubshm_transport.h b/src/brpc/ubshm_transport.h
index e756f049c6..eba126e63d 100644
--- a/src/brpc/ubshm_transport.h
+++ b/src/brpc/ubshm_transport.h
@@ -20,11 +20,14 @@
 #if BRPC_WITH_UBRING
 #include "brpc/socket.h"
 #include "brpc/channel.h"
-#include "brpc/adapter_transport.h"
+#include "brpc/transport.h"
+#include "brpc/transport_handshake.h"
 
 namespace brpc {
-class UBShmTransport : public AdapterTransport {
+class AdapterTransport;
+class UBShmTransport : public Transport {
     friend class TransportFactory;
+    friend class AdapterTransport;
     friend class ubring::UBShmEndpoint;
     friend class ubring::UBConnect;
 public:
@@ -48,6 +51,10 @@ class UBShmTransport : public AdapterTransport {
     void Release() override;
     int Reset(int32_t expected_nref) override;
     std::shared_ptr<AppConnect> Connect() override;
+    int CutFromIOBuf(butil::IOBuf* buf) override;
+    ssize_t CutFromIOBufList(butil::IOBuf** buf, size_t ndata) override;
+    int WaitEpollOut(butil::atomic<int>* epollout_butex,
+                     bool pollin, timespec duetime) override;
     void ProcessEvent(bthread_attr_t attr) override;
     void QueueMessage(InputMessageClosure& inputMsg, int* num_bthread_created, bool last_msg) override;
     void Debug(std::ostream &os) override;
@@ -55,16 +62,19 @@ class UBShmTransport : public AdapterTransport {
         CHECK(_ub_ep != NULL);
         return _ub_ep;
     }
+    static UBShmTransport* Get(const Socket* socket);
     static int ContextInitOrDie(bool serverOrNot, const void* _options);
+    int handshake_phase() const;
+    int handshake_version() const;
     static void* ProcessHandshakeAtClient(void* arg);
     static void* ProcessHandshakeAtServer(void* arg);
 private:
-    void SetHighSpeedAvailable(bool available) override;
-    ssize_t CutFromHighSpeedIOBufList(
-        butil::IOBuf** buf, size_t ndata) override;
-    int WaitHighSpeedEpollOut(butil::atomic<int>* epollout_butex,
-                              bool pollin, timespec duetime) override;
-    void StartServerHandshake() override;
+    AdapterTransport* adapter_transport() const;
+    handshake::HandshakeSession* handshake_session() const;
+    void FallbackToTcp();
+    void TryReadOnTcp();
+    void SetHighSpeedAvailable(bool available);
+    void StartServerHandshake();
 
     static bool OptionsAvailableForUB(const ChannelOptions* opt);
     static bool OptionsAvailableOverUB(const ServerOptions* opt);
diff --git a/test/brpc_rdma_unittest.cpp b/test/brpc_rdma_unittest.cpp
index b45b677d4e..7e0ce9a427 100644
--- a/test/brpc_rdma_unittest.cpp
+++ b/test/brpc_rdma_unittest.cpp
@@ -200,7 +200,7 @@ TEST_F(RdmaTest, client_close_before_hello_send) {
     ASSERT_EQ(0, connect(sockfd, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     Socket* s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
     close(sockfd);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -221,7 +221,7 @@ TEST_F(RdmaTest, client_hello_msg_invalid_magic_str) {
     ASSERT_EQ(0, connect(sockfd, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     Socket* s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
 
     uint8_t data[rdma::HELLO_V2_MSG_LEN_MIN];
     memcpy(data, "PRPC", 4);  // send as normal baidu_std protocol
@@ -230,7 +230,7 @@ TEST_F(RdmaTest, client_hello_msg_invalid_magic_str) {
     // A non-RDMA magic makes ParseRdmaHandshake return TRY_OTHERS and hand the
     // bytes to other protocols; it does not touch the endpoint state, so it
     // stays UNINIT (the old blocking handshake used to set FALLBACK_TCP here).
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
 
     StopServer();
 }
@@ -250,14 +250,14 @@ TEST_F(RdmaTest, client_close_during_hello_send) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
     memcpy(data, "RD", 2);
     ASSERT_EQ(2, write(sockfd1, data, 2));  // break in magic str
     usleep(100000);  // wait for server to handle the msg
     // Fewer than 4 magic bytes: ParseRdmaHandshake can't tell yet, returns
     // NOT_ENOUGH_DATA and leaves the endpoint UNINIT (the old blocking
     // handshake used to set S_HELLO_WAIT before reading the magic).
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
     close(sockfd1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -267,11 +267,11 @@ TEST_F(RdmaTest, client_close_during_hello_send) {
     ASSERT_EQ(0, connect(sockfd2, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
     memcpy(data, "RDMA", 4);
     ASSERT_EQ(4, write(sockfd2, data, 4));  // break after magic str
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
     close(sockfd2);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -281,7 +281,7 @@ TEST_F(RdmaTest, client_close_during_hello_send) {
     ASSERT_EQ(0, connect(sockfd3, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
     // Send the 4B magic plus a valid msg_len (=40) but no body, so the server
     // recognizes an RDMA v2 hello and waits for the remaining bytes. (A zero
     // msg_len would now be rejected up-front as a protocol error.)
@@ -290,7 +290,7 @@ TEST_F(RdmaTest, client_close_during_hello_send) {
     memcpy(data + 4, &v2_len, sizeof(v2_len));
     ASSERT_EQ(6, write(sockfd3, data, 6));  // magic + msg_len, body missing
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
     close(sockfd3);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -313,11 +313,11 @@ TEST_F(RdmaTest, client_hello_msg_invalid_len) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
     memcpy(data, "RDMA", 4);
     ASSERT_EQ(4, write(sockfd1, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
     memset(data + 4, 0, 36);
     ASSERT_EQ(36, write(sockfd1, data + 4, 36));  // Write invalid length.
     usleep(100000);  // wait for server to handle the msg
@@ -328,11 +328,11 @@ TEST_F(RdmaTest, client_hello_msg_invalid_len) {
     ASSERT_EQ(0, connect(sockfd2, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
     memcpy(data, "RDMA", 4);
     ASSERT_EQ(4, write(sockfd2, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
     uint16_t len = butil::HostToNet16(35);
     memcpy(data + 4, &len, sizeof(len));
     memset(data + 6, 0, 34);
@@ -360,11 +360,11 @@ TEST_F(RdmaTest, client_hello_msg_invalid_version) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
     memcpy(data, "RDMA", 4);
     ASSERT_EQ(4, write(sockfd1, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
     memcpy(data + 4, &len, 2);
     memset(data + 6, 0, 34);
     memcpy(data + 6, &ver, 2);  // hello_ver == 1, impl_ver == 0
@@ -377,12 +377,12 @@ TEST_F(RdmaTest, client_hello_msg_invalid_version) {
     // version check, breaking the intent of this UT.
     ASSERT_EQ(36, write(sockfd1, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
-    ASSERT_EQ(RdmaTransport::RDMA_OFF, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(RdmaTransport::RDMA_OFF, RdmaTransport::Get(s)->_rdma_state);
     uint32_t flags = 0;
     ASSERT_EQ(sizeof(flags), write(sockfd1, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
     sockfd1.reset(-1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -392,11 +392,11 @@ TEST_F(RdmaTest, client_hello_msg_invalid_version) {
     ASSERT_EQ(0, connect(sockfd2, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
     memcpy(data, "RDMA", 4);
     ASSERT_EQ(4, write(sockfd2, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
     memcpy(data + 4, &len, 2);
     memset(data + 6, 0, 32);
     memcpy(data + 8, &ver, 2);  // hello_ver == 0, impl_ver == 1
@@ -404,11 +404,11 @@ TEST_F(RdmaTest, client_hello_msg_invalid_version) {
     // write from data + 4 instead of data.
     ASSERT_EQ(36, write(sockfd2, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
-    ASSERT_EQ(RdmaTransport::RDMA_OFF, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(RdmaTransport::RDMA_OFF, RdmaTransport::Get(s)->_rdma_state);
     ASSERT_EQ(sizeof(flags), write(sockfd2, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
     sockfd2.reset(-1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -441,17 +441,17 @@ TEST_F(RdmaTest, client_hello_msg_invalid_sq_rq_block_size) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, write(sockfd1, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(36, write(sockfd1, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
-    ASSERT_EQ(RdmaTransport::RDMA_OFF, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(RdmaTransport::RDMA_OFF, RdmaTransport::Get(s)->_rdma_state);
     ASSERT_EQ(sizeof(flags), write(sockfd1, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
     sockfd1.reset(-1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -466,17 +466,17 @@ TEST_F(RdmaTest, client_hello_msg_invalid_sq_rq_block_size) {
     ASSERT_EQ(0, connect(sockfd2, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, write(sockfd2, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(36, write(sockfd2, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
-    ASSERT_EQ(RdmaTransport::RDMA_OFF, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(RdmaTransport::RDMA_OFF, RdmaTransport::Get(s)->_rdma_state);
     ASSERT_EQ(sizeof(flags), write(sockfd2, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
     sockfd2.reset(-1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -491,17 +491,17 @@ TEST_F(RdmaTest, client_hello_msg_invalid_sq_rq_block_size) {
     ASSERT_EQ(0, connect(sockfd3, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, write(sockfd3, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(36, write(sockfd3, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
-    ASSERT_EQ(RdmaTransport::RDMA_OFF, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(RdmaTransport::RDMA_OFF, RdmaTransport::Get(s)->_rdma_state);
     ASSERT_EQ(sizeof(flags), write(sockfd3, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
     sockfd3.reset(-1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -535,10 +535,10 @@ TEST_F(RdmaTest, client_close_after_qp_build) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(40, write(sockfd1, data, 40));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
     close(sockfd1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -572,17 +572,17 @@ TEST_F(RdmaTest, client_close_during_ack_send) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, write(sockfd1, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(36, write(sockfd1, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
     uint32_t flags = butil::HostToNet32(1);
     ASSERT_EQ(sizeof(flags), write(sockfd1, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::ESTABLISHED, RdmaTransport::Get(s)->handshake_phase());
     close(sockfd1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -616,18 +616,18 @@ TEST_F(RdmaTest, client_close_after_ack_send) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, write(sockfd1, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(36, write(sockfd1, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
     uint32_t flags = butil::HostToNet32(0);
     ASSERT_EQ(sizeof(flags), write(sockfd1, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
-    ASSERT_EQ(RdmaTransport::RDMA_OFF, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_state);
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(RdmaTransport::RDMA_OFF, RdmaTransport::Get(s)->_rdma_state);
     close(sockfd1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -637,17 +637,17 @@ TEST_F(RdmaTest, client_close_after_ack_send) {
     ASSERT_EQ(0, connect(sockfd2, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, write(sockfd2, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(36, write(sockfd2, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
     flags = butil::HostToNet32(1);
     ASSERT_EQ(sizeof(flags), write(sockfd2, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::ESTABLISHED, RdmaTransport::Get(s)->handshake_phase());
     close(sockfd2);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -681,17 +681,17 @@ TEST_F(RdmaTest, client_send_data_on_tcp_after_ack_send) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, write(sockfd1, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(36, write(sockfd1, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
     uint32_t flags = butil::HostToNet32(0);
     ASSERT_EQ(sizeof(flags), write(sockfd1, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(sizeof(flags), write(sockfd1, &flags, sizeof(flags)));
     usleep(100000);
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -701,17 +701,17 @@ TEST_F(RdmaTest, client_send_data_on_tcp_after_ack_send) {
     ASSERT_EQ(0, connect(sockfd2, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, write(sockfd2, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(36, write(sockfd2, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
     flags = butil::HostToNet32(1);
     ASSERT_EQ(sizeof(flags), write(sockfd2, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::ESTABLISHED, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(sizeof(flags), write(sockfd2, &flags, sizeof(flags)));
     usleep(100000);
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -741,7 +741,7 @@ TEST_F(RdmaTest, server_miss_before_hello_send) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -772,7 +772,7 @@ TEST_F(RdmaTest, server_close_before_hello_send) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -780,7 +780,7 @@ TEST_F(RdmaTest, server_close_before_hello_send) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, read(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     close(acc_fd);
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FAILED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::FAILED, RdmaTransport::Get(s)->handshake_phase());
     bthread_id_join(cntl.call_id());
 
     ASSERT_EQ(EEOF, cntl.ErrorCode());
@@ -808,7 +808,7 @@ TEST_F(RdmaTest, server_miss_during_magic_str) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -843,7 +843,7 @@ TEST_F(RdmaTest, server_close_during_magic_str) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -853,7 +853,7 @@ TEST_F(RdmaTest, server_close_during_magic_str) {
     usleep(100000);
     close(acc_fd);
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FAILED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::FAILED, RdmaTransport::Get(s)->handshake_phase());
     bthread_id_join(cntl.call_id());
 
     ASSERT_EQ(EEOF, cntl.ErrorCode());
@@ -881,7 +881,7 @@ TEST_F(RdmaTest, server_hello_invalid_magic_str) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -889,7 +889,7 @@ TEST_F(RdmaTest, server_hello_invalid_magic_str) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, read(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     ASSERT_EQ(4, write(acc_fd, "ABCD", 4));
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FAILED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::FAILED, RdmaTransport::Get(s)->handshake_phase());
     bthread_id_join(cntl.call_id());
 
     ASSERT_EQ(EPROTO, cntl.ErrorCode());
@@ -917,7 +917,7 @@ TEST_F(RdmaTest, server_miss_during_hello_msg) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -952,7 +952,7 @@ TEST_F(RdmaTest, server_close_during_hello_msg) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -962,7 +962,7 @@ TEST_F(RdmaTest, server_close_during_hello_msg) {
     ASSERT_EQ(2, write(acc_fd, "00", 2));
     close(acc_fd);
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FAILED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::FAILED, RdmaTransport::Get(s)->handshake_phase());
     bthread_id_join(cntl.call_id());
 
     ASSERT_EQ(EEOF, cntl.ErrorCode());
@@ -990,7 +990,7 @@ TEST_F(RdmaTest, server_hello_invalid_msg_len) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -1002,7 +1002,7 @@ TEST_F(RdmaTest, server_hello_invalid_msg_len) {
     memset(data + 6, 0, 32);
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FAILED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::FAILED, RdmaTransport::Get(s)->handshake_phase());
     bthread_id_join(cntl.call_id());
 
     ASSERT_EQ(EPROTO, cntl.ErrorCode());
@@ -1030,7 +1030,7 @@ TEST_F(RdmaTest, server_hello_invalid_version) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -1042,7 +1042,7 @@ TEST_F(RdmaTest, server_hello_invalid_version) {
     memset(data + 6, 0, 32);
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, read(acc_fd, data, 4));
     uint32_t* tmp = (uint32_t*)data;
     ASSERT_EQ(0, butil::NetToHost32(*tmp));
@@ -1073,7 +1073,7 @@ TEST_F(RdmaTest, server_hello_invalid_sq_rq_size) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -1094,7 +1094,7 @@ TEST_F(RdmaTest, server_hello_invalid_sq_rq_size) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
 
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, read(acc_fd, data, 4));
     uint32_t* tmp = (uint32_t*)data;
     ASSERT_EQ(0, butil::NetToHost32(*tmp));
@@ -1125,7 +1125,7 @@ TEST_F(RdmaTest, server_miss_after_ack) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -1146,7 +1146,7 @@ TEST_F(RdmaTest, server_miss_after_ack) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
 
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::ESTABLISHED, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, read(acc_fd, data, 4));
     uint32_t* tmp = (uint32_t*)data;
     ASSERT_EQ(1, butil::NetToHost32(*tmp));
@@ -1177,7 +1177,7 @@ TEST_F(RdmaTest, server_close_after_ack) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -1198,7 +1198,7 @@ TEST_F(RdmaTest, server_close_after_ack) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
 
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::ESTABLISHED, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, read(acc_fd, data, 4));
     uint32_t* tmp = (uint32_t*)data;
     ASSERT_EQ(1, butil::NetToHost32(*tmp));
@@ -1230,7 +1230,7 @@ TEST_F(RdmaTest, server_send_data_on_tcp_after_ack) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -1251,7 +1251,7 @@ TEST_F(RdmaTest, server_send_data_on_tcp_after_ack) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
 
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::ESTABLISHED, RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     bthread_id_join(cntl.call_id());
 
@@ -1322,7 +1322,7 @@ TEST_F(RdmaTest, v2_server_hello_bytes_baseline) {
     ASSERT_EQ(0, connect(sockfd, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);
     Socket* s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
 
     // Send a well-formed v2 hello so the server enters S_ACK_WAIT.
     rdma::v2_wire::HelloMessage msg{};
@@ -1340,7 +1340,7 @@ TEST_F(RdmaTest, v2_server_hello_bytes_baseline) {
     msg.Serialize(data + 4);
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(sockfd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
 
     // Read server's reply hello and assert its byte-level layout.
     uint8_t reply[rdma::HELLO_V2_MSG_LEN_MIN];
@@ -1365,7 +1365,7 @@ TEST_F(RdmaTest, v2_server_hello_bytes_baseline) {
     uint32_t flags = butil::HostToNet32(0);
     ASSERT_EQ(sizeof(flags), write(sockfd, &flags, sizeof(flags)));
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
 
     sockfd.reset(-1);
     usleep(100000);
@@ -1387,7 +1387,7 @@ TEST_F(RdmaTest, v2_server_preserves_coalesced_ack_after_extension) {
     usleep(100000);
     Socket* s = GetSocketFromServer(0);
     ASSERT_TRUE(s != NULL);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
 
     // Build a v2 hello with msg_len = 48 (40 base + 8B zero tail).
     rdma::v2_wire::HelloMessage msg{};
@@ -1411,7 +1411,7 @@ TEST_F(RdmaTest, v2_server_preserves_coalesced_ack_after_extension) {
     ASSERT_EQ(sizeof(buf), write(sockfd, buf, sizeof(buf)));
     usleep(100000);
 
-    ASSERT_EQ(RdmaTransport::ESTABLISHED, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::ESTABLISHED, RdmaTransport::Get(s)->handshake_phase());
 
     sockfd.reset(-1);
     usleep(100000);
@@ -1433,7 +1433,7 @@ TEST_F(RdmaTest, v2_server_rejects_oversized_msg_len) {
     usleep(100000);
     Socket* s = GetSocketFromServer(0);
     ASSERT_TRUE(s != NULL);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
 
     // Build a v2 hello with msg_len = 4097 (HELLO_V2_MSG_LEN_MAX + 1).
     // We only send the 40B base; the server must reject before reading
@@ -1584,14 +1584,14 @@ TEST_F(RdmaTest, v3_server_hello_bytes_baseline) {
     ASSERT_EQ(0, connect(sockfd, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);
     Socket* s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
 
     // Send a valid v3 hello.
     std::string packet = MakeV3Packet(MakeValidV3Hello());
     ASSERT_EQ((ssize_t)packet.size(),
               write(sockfd, packet.data(), packet.size()));
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
 
     // Read server's reply hello: 4B magic + 4B pb_size + body.
     uint8_t reply_magic[4];
@@ -1621,7 +1621,7 @@ TEST_F(RdmaTest, v3_server_hello_bytes_baseline) {
     ASSERT_EQ((ssize_t)sizeof(flags),
               write(sockfd, &flags, sizeof(flags)));
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
 
     sockfd.reset(-1);
     usleep(100000);
@@ -1736,8 +1736,8 @@ TEST_F(RdmaTest, v3_server_invalid_sq_size_falls_back) {
 
     // Server validated the hello as invalid -> _rdma_state = RDMA_OFF,
     // but still proceeds to S_ACK_WAIT (sends its own reply hello).
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
-    ASSERT_EQ(RdmaTransport::RDMA_OFF, static_cast<RdmaTransport*>(s->_transport.get())->_rdma_state);
+    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(RdmaTransport::RDMA_OFF, RdmaTransport::Get(s)->_rdma_state);
 
     // Drain server's reply hello (content not asserted here; covered
     // by v3_server_hello_bytes_baseline).
@@ -1755,7 +1755,7 @@ TEST_F(RdmaTest, v3_server_invalid_sq_size_falls_back) {
     ASSERT_EQ((ssize_t)sizeof(flags),
               write(sockfd, &flags, sizeof(flags)));
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
 
     sockfd.reset(-1);
     usleep(100000);
@@ -1828,7 +1828,7 @@ TEST_F(RdmaTest, v3_server_accepts_client_hello_with_ece) {
     usleep(100000);
 
     ASSERT_EQ(RdmaTransport::S_ACK_WAIT,
-              static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+              RdmaTransport::Get(s)->handshake_phase());
 
     rdma::RdmaHello reply;
     ReadServerV3Reply(sockfd, &reply);
@@ -1838,7 +1838,7 @@ TEST_F(RdmaTest, v3_server_accepts_client_hello_with_ece) {
     ASSERT_EQ((ssize_t)sizeof(flags), write(sockfd, &flags, sizeof(flags)));
     usleep(100000);
     ASSERT_EQ(RdmaTransport::FALLBACK_TCP,
-              static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+              RdmaTransport::Get(s)->handshake_phase());
 
     sockfd.reset(-1);
     usleep(100000);
@@ -1956,9 +1956,9 @@ TEST_F(RdmaTest, client_alloc_resource_fail_fallback_tcp) {
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
     ASSERT_EQ(RdmaTransport::FALLBACK_TCP,
-              static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+              RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF,
-              static_cast<RdmaTransport*>(s->_transport.get())->_rdma_state);
+              RdmaTransport::Get(s)->_rdma_state);
     // The socket must not be failed, otherwise it can no longer carry TCP.
     ASSERT_FALSE(s->Failed());
 
@@ -1984,7 +1984,7 @@ TEST_F(RdmaTest, server_alloc_resource_fail_fallback_tcp) {
     Socket* s = GetSocketFromServer(0);
     ASSERT_TRUE(s != NULL);
     ASSERT_EQ(RdmaTransport::UNINIT,
-              static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+              RdmaTransport::Get(s)->handshake_phase());
 
     // Send a well-formed v2 hello: the negotiation succeeds
     // but the resource allocation does not.
@@ -2005,9 +2005,9 @@ TEST_F(RdmaTest, server_alloc_resource_fail_fallback_tcp) {
               write(sockfd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     usleep(100000);
     ASSERT_EQ(RdmaTransport::S_ACK_WAIT,
-              static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+              RdmaTransport::Get(s)->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF,
-              static_cast<RdmaTransport*>(s->_transport.get())->_rdma_state);
+              RdmaTransport::Get(s)->_rdma_state);
     ASSERT_FALSE(s->Failed());
 
     // Ack without RDMA so that the server finishes the handshake in TCP mode.
@@ -2015,7 +2015,7 @@ TEST_F(RdmaTest, server_alloc_resource_fail_fallback_tcp) {
     ASSERT_EQ(sizeof(flags), write(sockfd, &flags, sizeof(flags)));
     usleep(100000);
     ASSERT_EQ(RdmaTransport::FALLBACK_TCP,
-              static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+              RdmaTransport::Get(s)->handshake_phase());
     ASSERT_FALSE(s->Failed());
 
     sockfd.reset(-1);
@@ -2047,7 +2047,7 @@ TEST_F(RdmaTest, try_global_disable_rdma) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, static_cast<RdmaTransport*>(s->_transport.get())->handshake_phase());
+    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
     bthread_id_join(cntl.call_id());
     ASSERT_EQ(0, cntl.ErrorCode());
 
@@ -2242,9 +2242,9 @@ static const int RPC_NUM = 1024;
 
 void DumpRdmaEndpointInfo(Socket* client, Socket* server) {
     std::cout << std::endl << "client:";
-    static_cast<RdmaTransport*>(client->_transport.get())->_rdma_ep->DebugInfo(std::cout);
+    RdmaTransport::Get(client)->_rdma_ep->DebugInfo(std::cout);
     std::cout << std::endl << "server:";
-    static_cast<RdmaTransport*>(server->_transport.get())->_rdma_ep->DebugInfo(std::cout);
+    RdmaTransport::Get(server)->_rdma_ep->DebugInfo(std::cout);
 }
 
 TEST_P(RdmaRpcTest, send_rpcs_in_one_qp) {
@@ -2638,7 +2638,7 @@ TEST_P(RdmaRpcTest, verbs_error_handling) {
     wr.sg_list = &sge;
     wr.num_sge = 1;
     ibv_send_wr* bad = NULL;
-    auto rdma_transport = static_cast<RdmaTransport*>(s->_transport.get());
+    auto rdma_transport = RdmaTransport::Get(s);
     ibv_post_send(rdma_transport->_rdma_ep->_resource->qp, &wr, &bad);
     bthread_id_join(cntl.call_id());
     ASSERT_EQ(ERDMA, cntl.ErrorCode());

From 27d8f89b9aaac8893df4973f4b4b992c3755344a Mon Sep 17 00:00:00 2001
From: Gzure <740684863@qq.com>
Date: Tue, 18 Aug 2026 18:28:36 +0800
Subject: [PATCH 07/11] Move handshake codecs into common session

---
 Makefile                                   |   2 +-
 docs/cn/handshake_common_design.md         | 155 +++---
 src/brpc/adapter_transport.h               |   2 +-
 src/brpc/handshake/handshake_frame.cpp     | 235 +++++++++
 src/brpc/handshake/handshake_frame.h       |  92 ++++
 src/brpc/handshake/handshake_io.cpp        | 145 ++++++
 src/brpc/handshake/handshake_io.h          |  89 ++++
 src/brpc/rdma_handshake.cpp                | 528 ++++++++-------------
 src/brpc/rdma_handshake.h                  | 158 +++---
 src/brpc/rdma_handshake_constants.h        |  25 +
 src/brpc/rdma_handshake_server.cpp         | 234 ++++-----
 src/brpc/rdma_transport.cpp                | 121 ++---
 src/brpc/socket.h                          |   4 +
 src/brpc/transport_handshake.cpp           | 287 ++++++-----
 src/brpc/transport_handshake.h             |  99 ++--
 src/brpc/ubshm/ub_endpoint.cpp             | 224 ++++-----
 src/brpc/ubshm/ub_endpoint.h               |   2 +-
 test/brpc_transport_handshake_unittest.cpp | 350 +++++++++-----
 18 files changed, 1564 insertions(+), 1188 deletions(-)
 create mode 100644 src/brpc/handshake/handshake_frame.cpp
 create mode 100644 src/brpc/handshake/handshake_frame.h
 create mode 100644 src/brpc/handshake/handshake_io.cpp
 create mode 100644 src/brpc/handshake/handshake_io.h

diff --git a/Makefile b/Makefile
index 86de388448..90be5516c3 100644
--- a/Makefile
+++ b/Makefile
@@ -203,7 +203,7 @@ JSON2PB_DIRS = src/json2pb
 JSON2PB_SOURCES = $(foreach d,$(JSON2PB_DIRS),$(wildcard $(addprefix $(d)/*,$(SRCEXTS))))
 JSON2PB_OBJS = $(addsuffix .o, $(basename $(JSON2PB_SOURCES))) 
 
-BRPC_DIRS = src/brpc src/brpc/details src/brpc/builtin src/brpc/policy src/brpc/policy/mysql src/brpc/rdma
+BRPC_DIRS = src/brpc src/brpc/details src/brpc/builtin src/brpc/handshake src/brpc/policy src/brpc/policy/mysql src/brpc/rdma
 THRIFT_SOURCES = $(foreach d,$(BRPC_DIRS),$(wildcard $(addprefix $(d)/thrift*,$(SRCEXTS))))
 EXCLUDE_SOURCES = $(foreach d,$(BRPC_DIRS),$(wildcard $(addprefix $(d)/event_dispatcher_*,$(SRCEXTS))))
 BRPC_SOURCES_ALL = $(foreach d,$(BRPC_DIRS),$(wildcard $(addprefix $(d)/*,$(SRCEXTS))))
diff --git a/docs/cn/handshake_common_design.md b/docs/cn/handshake_common_design.md
index d7e63d7206..5fcfbc5d36 100644
--- a/docs/cn/handshake_common_design.md
+++ b/docs/cn/handshake_common_design.md
@@ -119,9 +119,11 @@ Hello 中携带：
 ```text
 src/brpc/
     adapter_transport.h/.cpp     # Socket 顶层 Transport、TCP-first 路由与状态发布
-    transport_handshake.h/.cpp   # HandshakeSession 与 SocketHandshakeIO
-    rdma_handshake.h/.cpp        # RDMA v2/v3 wire adapter
-    rdma_handshake_server.h/.cpp # RDMA 标准 server parser/fallback
+    transport_handshake.h/.cpp   # HandshakeSession、codec 与资源阶段编排
+    handshake/handshake_io.*     # blocking fd I/O 与增量 IOBuf 输入适配
+    handshake/handshake_frame.*  # fixed/U16/U32 通用 framing
+    rdma_handshake.h/.cpp        # RDMA v2/v3 payload 字段 adapter
+    rdma_handshake_server.h/.cpp # RDMA 标准 server parser，fallback 复用 Session/FrameCodec
     rdma_handshake.proto         # RDMA v3 wire message
     rdma_transport.h/.cpp        # 独立 RDMA Transport、握手回调与数据面
     ubshm_transport.h/.cpp       # 独立 UBSHM Transport、握手回调与数据面
@@ -133,8 +135,9 @@ src/brpc/
 flowchart TB
     S["Socket"] --> UT["AdapterTransport\nTCP-first 路由与状态发布"]
     UT --> TCP["TcpTransport\n默认数据面 / fallback"]
-    UT --> HS["HandshakeSession\nclient/server driver + lifecycle"]
+    UT --> HS["HandshakeSession\ndriver + codec + resource stages"]
     HS --> IO["SocketHandshakeIO\nReadExact / WriteAll / readable butex"]
+    HS --> FC["FrameCodec\nmagic / length / incremental parse"]
     UT --> RT["RdmaTransport"]
     UT --> UTRA["UrmaTransport"]
     UT --> BT["UBShmTransport"]
@@ -144,7 +147,7 @@ flowchart TB
     BT --> BE["UBShmEndpoint\nUBRing / Shared Memory"]
 ```
 
-`Socket::_transport` 始终指向最上层的 `AdapterTransport`。它组合一个默认 `TcpTransport` 和至多一个独立的 `RdmaTransport`、`UrmaTransport` 或 `UBShmTransport`，并决定当前数据走哪个 Transport。`HandshakeSession` 驱动一次升级尝试的公共步骤；具体协议 adapter 通过回调完成 Hello/ACK wire codec 和资源协商。Endpoint 不持有 TCP Transport，也不执行 TCP fd 读写。
+`Socket::_transport` 始终指向最上层的 `AdapterTransport`。它组合一个默认 `TcpTransport` 和至多一个独立的 `RdmaTransport`、`UrmaTransport` 或 `UBShmTransport`，并决定当前数据走哪个 Transport。`HandshakeSession` 持有公共 `FrameCodec`，统一 Hello/ACK 的 framing、I/O、状态转换和资源阶段调用；具体协议只通过 callback 编解码 payload 字段并执行被 Session 调度的资源动作。Endpoint 不持有 TCP Transport，也不执行 TCP fd 读写。
 
 ## 4.1 选定架构：Handshake 位于 Transport 层
 
@@ -154,8 +157,9 @@ flowchart TB
 flowchart TB
     Socket["Socket"] --> UT["AdapterTransport\n顶层 Transport"]
     UT --> TCP["TcpTransport\n默认控制面与 TCP 数据面"]
-    UT --> HS["HandshakeSession\n连接协商 / 版本 / ACK / fallback"]
+    UT --> HS["HandshakeSession\nframing / 字段 codec / 资源阶段 / fallback"]
     HS --> IO["SocketHandshakeIO"]
+    HS --> FC["FrameCodec"]
     UT --> T["RdmaTransport / UrmaTransport / UBShmTransport\n独立 Transport"]
     T --> R["RdmaEndpoint\n仅高速数据面"]
     T --> U["UrmaEndpoint\n仅高速数据面"]
@@ -273,7 +277,7 @@ enum class Phase {
 }  // namespace brpc
 ```
 
-这可以统一当前 RDMA 的 `RemoteHelloResult` 和 URMA 的 `int + bool negotiated`，也覆盖 UBSHM 的状态转换。
+这统一了 RDMA、URMA 与 UBSHM 在字段解析后的成功、fallback、半包和错误结果，也避免协议 adapter 自行推进公共状态。
 
 ### 5.2 字节流接口
 
@@ -311,7 +315,7 @@ public:
 
 实现方式：
 
-- client：把当前 `ReadFromFd/WriteToFd` 封装成 `SocketHandshakeIO`；
+- client：通过 `SocketHandshakeIO` 统一执行 blocking fd 读写；
 - server：把 `butil::IOBuf` 封装成 `IOBufHandshakeInput`；
 - UBSHM 当前 server 也使用 fd 读取，可先使用 `SocketHandshakeIO`，后续再迁移到增量解析；
 - RDMA 的 `rdma_handshake_server.cpp` 可以直接使用 `HandshakeInput`。
@@ -335,20 +339,19 @@ struct FrameSpec {
 
 class FrameCodec {
 public:
-    static Result ReadMagic(HandshakeIO* io,
+    static FrameResult Encode(const FrameSpec& spec,
+                              const std::string& payload,
+                              std::string* frame);
+    static FrameResult ReadFrame(HandshakeIO* io,
                             const FrameSpec& spec,
-                            std::string* magic);
-
-    static Result ReadFrame(HandshakeIO* io,
-                            const FrameSpec& spec,
-                            std::string* frame);
-
-    static Result ParseBufferedFrame(HandshakeInput* input,
+                            bool push_back_on_not_mine,
+                            std::string* payload);
+    static FrameResult ParseBufferedFrame(HandshakeInput* input,
                                       const FrameSpec& spec,
-                                      std::string* frame);
-
-    static Result DrainFrame(HandshakeIO* io,
-                             const FrameSpec& spec);
+                                      std::string* payload);
+    static FrameResult WriteFrame(HandshakeIO* io,
+                                  const FrameSpec& spec,
+                                  const std::string& payload);
 };
 ```
 
@@ -366,47 +369,32 @@ public:
 
 ### 5.4 协议适配器
 
-每个传输提供自己的协议适配器：
+每个传输提供自己的字段 codec。`HandshakeSession` 持有 codec 描述并负责调用，协议实现只看到去掉 magic/length 后的 payload：
 
 ```cpp
-class HandshakeProtocol {
-public:
-    virtual ~HandshakeProtocol() = default;
-
-    virtual int Version() const = 0;
-    virtual const FrameSpec& HelloFrameSpec() const = 0;
-
-    // 构造本地 Hello payload。
-    virtual Result BuildHello(std::string* out,
-                              bool negotiable) = 0;
-
-    // 校验并解析对端 Hello；只做协议层校验。
-    virtual Result ParseHello(const std::string& frame,
-                              std::shared_ptr<void>* parsed) = 0;
-
-    // 交给具体 endpoint 创建/导入高速资源。
-    virtual Result Negotiate(void* parsed) = 0;
-
-    // 构造和解析传输特有 ACK。
-    virtual Result BuildAck(bool enabled, std::string* out) = 0;
-    virtual Result ParseAck(const std::string& ack, bool* enabled) = 0;
+struct HandshakeCodec {
+    int protocol_version;
+    FrameSpec hello_frame;
+    FrameSpec ack_frame;
+    std::function<Result(bool, std::string*)> build_hello;
+    std::function<Result(const std::string&)> parse_hello;
+    std::function<Result(bool, std::string*)> build_ack;
+    std::function<Result(const std::string&, bool*)> parse_ack;
 };
 ```
 
-实际实现中不建议使用裸 `shared_ptr<void>`，更适合使用各协议自己的 `ParsedHello` 结构配合回调，或者让 `HandshakeSession` 只传递步骤结果，由协议 callback 保存强类型上下文。
-
-建议第一版采用回调方式，避免公共头文件包含协议专有类型：
+资源动作同样作为回调注册到 Session，但强类型上下文保留在协议 Transport 内：
 
 ```cpp
-struct HandshakeCallbacks {
-    std::function<Result(std::string* hello)> build_hello;
-    std::function<Result(const std::string& hello)> parse_remote_hello;
-    std::function<Result(bool enabled, std::string* ack)> build_ack;
-    std::function<Result(const std::string& ack, bool* enabled)> parse_ack;
+struct ClientHandshakeCallbacks {
+    HandshakeCodec codec;
+    std::function<Result()> prepare_resources;
     std::function<Result()> negotiate_resources;
 };
 ```
 
+这样公共头文件不包含 `ibv_*`、`urma_*` 或 UBRING 类型；RDMA 的 `ParsedHello`、URMA 的 Jetty 参数和 UBSHM 的共享内存描述仍由各自 callback 捕获。
+
 ## 6. HandshakeSession 状态机
 
 ### 6.1 Client 流程
@@ -415,10 +403,10 @@ struct HandshakeCallbacks {
 INIT
   -> build_hello
   -> send_hello
-  -> receive_remote_hello
+  -> parse_hello
   -> parse/validate
   -> negotiate_resources
-  -> receive_remote_ack 或发送本地 ACK
+  -> build_ack / send_ack
   -> ESTABLISHED
 ```
 
@@ -450,15 +438,15 @@ server 解析必须保留 `NEED_MORE_DATA`：
 - 后续 URMA/UBSHM 如果接入统一 server parser，也需要同样行为；
 - 未读完整时不得消费输入缓冲区。
 
-### 6.3 公共驱动不负责的动作
+### 6.3 公共驱动与具体资源实现的边界
 
-`HandshakeSession` 通过 callback 驱动协议步骤，不直接依赖具体资源类型：
+`HandshakeSession` 负责资源阶段的进入条件、调用顺序、结果转换和 fallback 发布，但不直接依赖具体资源类型：
 
 - RDMA：回调中执行 `AllocateResources/BringUpQp`；
 - URMA：回调中执行 `AllocateResources/ImportPeer`；
 - UBSHM：回调中执行 `AllocateClientResources/AllocateServerResources`。
 
-这样可以保证握手公共组件不依赖三种数据面 API。
+也就是说，资源操作被“提到” Session 的状态机中统一编排，具体 `Allocate/Import/BringUp/Map` 实现仍在各 Transport/Endpoint 回调中，从而避免公共组件依赖三种数据面 API。
 
 ## 7. 三种传输的适配方式
 
@@ -563,7 +551,7 @@ Endpoint 仍然拥有：
 - data path；
 - transport-specific error handling。
 
-`AdapterTransport` 拥有 TCP 路由、公共握手阶段和 active Transport 选择；具体高速 Transport 拥有 protocol callback 和 Endpoint 生命周期。公共 driver 不直接依赖 Endpoint 类型。
+`AdapterTransport` 拥有 TCP 路由、公共握手阶段和 active Transport 选择；`HandshakeSession` 拥有 framing/codec/资源阶段编排；具体高速 Transport 提供字段与资源 callback 并管理 Endpoint 生命周期。公共 driver 不直接依赖 Endpoint 类型。
 
 ## 9. 兼容性和安全约束
 
@@ -656,37 +644,39 @@ Hello valid
 
 ### Phase 0：建立行为基线
 
-- 为 RDMA、URMA、UBSHM 现有 handshake 增加或补齐单元测试；
-- 固化现有 wire format 样例；
-- 记录状态转换和 fallback 行为。
+- **已完成（受控源码）**：为公共状态机补齐成功、资源失败、fallback、增量 ACK 等单元测试；
+- **已完成**：RDMA v2/v3 与 UBSHM v2 的既有兼容性测试继续固化 wire format；
+- **已完成**：记录状态转换、半包不消费和 fallback 发布顺序；
+- **URMA 待其源码合入**：复用同一组 framing/driver 测试模板补齐 v2/v3 样例。
 
 ### Phase 1：抽取公共 I/O 和 framing
 
-- 新增 `src/brpc/handshake/handshake_io.*`；
-- 新增 `src/brpc/handshake/handshake_frame.*`；
-- 先迁移 UBSHM 固定长度握手；
-- 再迁移 URMA v2；
-- 最后迁移 RDMA v2/v3。
+- **已完成**：新增 `src/brpc/handshake/handshake_io.*`；
+- **已完成**：新增 `src/brpc/handshake/handshake_frame.*`；
+- **已完成**：迁移 UBSHM 固定长度握手；
+- **URMA 待其源码合入**：使用 `U16_TOTAL_LENGTH/U32_BODY_LENGTH` 迁移 v2/v3；
+- **已完成**：迁移 RDMA v2/v3，协议 adapter 只解析 payload 字段。
 
 ### Phase 2：抽取公共 driver
 
-- 引入统一 `Result/Phase`；
-- 将 client/server 的握手阶段迁移到 `HandshakeSession`；
-- 保留各 endpoint 的资源协商回调；
-- 统一 fallback 和错误处理。
+- **已完成**：引入统一 `FrameResult/StepResult/Phase`；
+- **已完成**：client/server 的 framing、codec 调用和握手阶段迁移到 `HandshakeSession`；
+- **已完成**：Session 统一编排资源回调，Endpoint 保留强类型资源实现；
+- **已完成**：统一 fallback、错误处理和 established 发布顺序。
 
 ### Phase 3：清理旧实现
 
-- 删除三套重复的 `ReadFromFd/WriteToFd` 握手代码；
-- 删除可替代的 magic/length 解析代码；
-- 保留各协议的 wire codec 和资源适配器；
-- 更新 CMake、Bazel 和相关测试目标。
+- **已完成（RDMA/UBSHM）**：删除重复的握手 fd 读写，统一使用 `SocketHandshakeIO`；
+- **已完成（RDMA/UBSHM）**：删除可替代的 magic/length 解析，统一使用 `FrameCodec`；
+- **已完成**：仅保留各协议的 payload 字段 codec 和资源回调；
+- **已完成**：CMake/Bazel 通过递归 glob 收录，Makefile 增加 `src/brpc/handshake`，并更新公共测试；
+- **URMA 待其源码合入**：删除 Endpoint 中对应旧握手实现。
 
 ## 12. 主要风险和规避方式
 
 ### 风险一：公共抽象过度绑定 Socket
 
-规避：状态发布和协议 adapter 不依赖 Endpoint；仅最外层 `SocketHandshakeIO` 适配器持有非 owning `Socket*`，集中封装 fd 等待与读写。后续如需脱离 brpc Socket 测试，可在该适配器之下再拆纯虚 `HandshakeIO`。
+规避：状态发布和协议 adapter 不依赖 Endpoint；纯虚 `HandshakeIO` 隔离字节流，只有 `SocketHandshakeIO` 持有 non-owning `Socket*` 并集中封装 fd 等待与读写，单测可直接注入内存实现。
 
 ### 风险二：混淆不同长度字段语义
 
@@ -710,7 +700,7 @@ RDMA/URMA/UBSHM 的长度字段并不完全相同。规避：使用 `FrameSpec::
 
 ```text
 公共：TCP 握手 I/O、frame framing、magic/length、增量解析、状态驱动、ACK/fallback 结果
-私有：Hello payload、版本语义、资源协商、QP/Jetty/SHM 创建、数据面 completion
+私有：Hello payload、版本语义、具体 QP/Jetty/SHM 资源操作、数据面 completion
 ```
 
 实施上以当前 RDMA 握手状态机为基线：先保留 #3350 已接入的标准 server 协议解析流程，再迁移 UBSHM，最后在 URMA 分支重新基于公共接口适配。这样可以直接继承已经过社区修复和测试的 fallback 语义。
@@ -734,6 +724,7 @@ classDiagram
     }
     class HandshakeSession {
         -SocketHandshakeIO io
+        -FrameCodec frame_codec
         -atomic phase
         -int protocol_version
         +RunClient(callbacks)
@@ -744,6 +735,8 @@ classDiagram
     }
     class RdmaTransport
     class RdmaHandshakeAdapter
+    class HandshakeCodec
+    class FrameCodec
     class UrmaTransport
     class UBShmTransport
     class HighSpeedEndpoint
@@ -759,6 +752,8 @@ classDiagram
     AdapterTransport *-- UBShmTransport
     AdapterTransport *-- HandshakeSession
     HandshakeSession *-- SocketHandshakeIO
+    HandshakeSession --> FrameCodec
+    HandshakeSession o-- HandshakeCodec
     RdmaTransport --> RdmaHandshakeAdapter
     RdmaTransport --> HighSpeedEndpoint
     UBShmTransport --> HighSpeedEndpoint
@@ -766,19 +761,19 @@ classDiagram
 
 `AdapterTransport` 是安装在 `Socket` 上的最上层 TCP-first Transport：`UNINITIALIZED/NEGOTIATING/FALLBACK_TCP` 都委托给 `TcpTransport`，仅当 `HandshakeSession` release 发布 `ESTABLISHED` 后才委托给所选的 RDMA/URMA/UBSHM Transport。成功升级后的 TCP 控制连接只允许 EOF，不再接受应用数据。
 
-`HandshakeSession::RunClient/RunServer` 统一执行资源准备、Hello 收发、远端参数协商、ACK 收发以及 established/fallback/failed 发布。RDMA/UBSHM 仅通过 callback 提供 wire codec 和资源操作；RDMA server 的 `STEP_NEED_MORE` 仍由 bRPC 标准 parser 增量驱动，UBSHM server 使用同一驱动的 blocking 模式。
+`HandshakeSession::RunClient/RunServer` 持有 `HandshakeCodec` 并统一执行 framing、Hello/ACK 收发、字段 codec 调用、资源准备/协商回调以及 established/fallback/failed 发布。RDMA/UBSHM callback 只解析协议字段或执行具体资源动作；RDMA server 的 `STEP_NEED_MORE` 仍由 bRPC 标准 parser 增量驱动，UBSHM server 使用同一驱动的 blocking 模式。
 
 ### 14.1 当前完成度
 
 | 项目 | 状态 | 说明 |
 |---|---|---|
 | TCP-first 路由 | 已实现 | `Socket` 持有顶层 `AdapterTransport`；其组合 `TcpTransport` 和一个独立高速 `Transport` |
-| 公共握手处理 | 已实现 | `RunClient/RunServer` 统一 Hello、资源协商、ACK、fallback 和错误流程 |
-| RDMA client/server | 已迁移 | wire adapter、fallback server 和 v3 proto 已全部迁至 `src/brpc`；server 保留 #3350 的标准增量解析流程 |
-| UBSHM client/server | 已迁移公共驱动 | server 当前使用 blocking 模式；后续只需把输入方式迁移到标准 parser |
+| 公共握手处理 | 已实现 | `RunClient/RunServer` 统一 FrameCodec、字段 codec、资源回调、ACK、fallback 和错误流程 |
+| RDMA client/server | 已迁移 | v2/v3 adapter 只编解码 payload 字段；真实 RDMA 与无 RDMA Endpoint 的 server fallback 都由 Session 处理 framing/ACK；server 保留 #3350 的标准增量解析流程 |
+| UBSHM client/server | 已迁移 | 固定 64 字节 framing、2 字节 magic、ACK 和 fd I/O 已进入公共组件；server 当前仍使用 blocking 输入 |
 | URMA | 待迁移 | origin/master 暂无受版本控制的 URMA Transport；合入后保留独立 `UrmaTransport`，由顶层 `AdapterTransport` 组合并复用 `HandshakeSession` |
-| RDMA Protocol adapter | 已实现 | `RdmaHandshakeAdapter` 显式接收 enabled 状态，不再读取 Transport/Socket 私有状态 |
-| 通用 FrameCodec | 待实现 | 当前保留 RDMA 已验证的 v2/v3 framing，后续与 URMA/UBSHM 一起抽取 |
+| RDMA Protocol adapter | 已实现 | `RdmaHandshakeAdapter` 只构造/解析 v2/v3 payload 字段，不再读写 fd 或消费 `IOBuf` |
+| 通用 FrameCodec | 已实现 | 支持 fixed、U16 总长度、U32 body 长度、2/4 字节 magic、blocking I/O 和增量 `IOBuf` 解析 |
 
 ### 14.2 必须继承的修复语义
 
diff --git a/src/brpc/adapter_transport.h b/src/brpc/adapter_transport.h
index 25cbb666c0..487b5ab548 100644
--- a/src/brpc/adapter_transport.h
+++ b/src/brpc/adapter_transport.h
@@ -53,6 +53,7 @@ class AdapterTransport : public Transport {
 
     int handshake_phase() const { return _handshake.phase(); }
     int handshake_version() const { return _handshake.protocol_version(); }
+    handshake::HandshakeSession* handshake_session() { return &_handshake; }
     Transport* high_speed_transport() const {
         return _high_speed_transport.get();
     }
@@ -67,7 +68,6 @@ class AdapterTransport : public Transport {
     ~AdapterTransport() override;
 
     Transport* ActiveTransport() const;
-    handshake::HandshakeSession* handshake_session() { return &_handshake; }
     void SetHighSpeedAvailable(bool available);
     void StartServerHandshake();
     void FallbackToTcp();
diff --git a/src/brpc/handshake/handshake_frame.cpp b/src/brpc/handshake/handshake_frame.cpp
new file mode 100644
index 0000000000..f25e50c15c
--- /dev/null
+++ b/src/brpc/handshake/handshake_frame.cpp
@@ -0,0 +1,235 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "brpc/handshake/handshake_frame.h"
+
+#include <cstdint>
+#include <cstring>
+#include <limits>
+
+#include "butil/sys_byteorder.h"
+
+namespace brpc {
+namespace handshake {
+
+size_t FrameCodec::LengthFieldSize(const FrameSpec& spec) {
+    switch (spec.length_encoding) {
+    case FrameSpec::FIXED: return 0;
+    case FrameSpec::U16_TOTAL_LENGTH: return sizeof(uint16_t);
+    case FrameSpec::U32_BODY_LENGTH: return sizeof(uint32_t);
+    }
+    return 0;
+}
+
+FrameResult FrameCodec::DecodeLength(const FrameSpec& spec,
+                                     const void* header,
+                                     size_t* frame_len) {
+    const size_t length_size = LengthFieldSize(spec);
+    const size_t header_len = spec.magic_len + length_size;
+    if (spec.min_frame_len < header_len ||
+        spec.max_frame_len < spec.min_frame_len) {
+        return FRAME_PROTOCOL_ERROR;
+    }
+
+    if (spec.length_encoding == FrameSpec::FIXED) {
+        if (spec.min_frame_len != spec.max_frame_len) {
+            return FRAME_PROTOCOL_ERROR;
+        }
+        *frame_len = spec.min_frame_len;
+    } else if (spec.length_encoding == FrameSpec::U16_TOTAL_LENGTH) {
+        uint16_t total_be = 0;
+        memcpy(&total_be, static_cast<const char*>(header) + spec.magic_len,
+               sizeof(total_be));
+        *frame_len = butil::NetToHost16(total_be);
+    } else {
+        uint32_t body_be = 0;
+        memcpy(&body_be, static_cast<const char*>(header) + spec.magic_len,
+               sizeof(body_be));
+        const size_t body_len = butil::NetToHost32(body_be);
+        if (body_len > std::numeric_limits<size_t>::max() - header_len) {
+            return FRAME_PROTOCOL_ERROR;
+        }
+        *frame_len = header_len + body_len;
+    }
+
+    if (*frame_len < spec.min_frame_len ||
+        *frame_len > spec.max_frame_len) {
+        return FRAME_PROTOCOL_ERROR;
+    }
+    return FRAME_OK;
+}
+
+FrameResult FrameCodec::Encode(const FrameSpec& spec,
+                               const std::string& payload,
+                               std::string* frame) {
+    if (frame == NULL || (spec.magic_len != 0 && spec.magic == NULL)) {
+        return FRAME_PROTOCOL_ERROR;
+    }
+    const size_t length_size = LengthFieldSize(spec);
+    const size_t header_len = spec.magic_len + length_size;
+    if (payload.size() > std::numeric_limits<size_t>::max() - header_len) {
+        return FRAME_PROTOCOL_ERROR;
+    }
+    const size_t total_len = header_len + payload.size();
+    if (total_len < spec.min_frame_len || total_len > spec.max_frame_len) {
+        return FRAME_PROTOCOL_ERROR;
+    }
+    if (spec.length_encoding == FrameSpec::FIXED &&
+        spec.min_frame_len != spec.max_frame_len) {
+        return FRAME_PROTOCOL_ERROR;
+    }
+    if (spec.length_encoding == FrameSpec::U16_TOTAL_LENGTH &&
+        total_len > std::numeric_limits<uint16_t>::max()) {
+        return FRAME_PROTOCOL_ERROR;
+    }
+    if (spec.length_encoding == FrameSpec::U32_BODY_LENGTH &&
+        payload.size() > std::numeric_limits<uint32_t>::max()) {
+        return FRAME_PROTOCOL_ERROR;
+    }
+
+    frame->clear();
+    frame->reserve(total_len);
+    if (spec.magic_len != 0) {
+        frame->append(spec.magic, spec.magic_len);
+    }
+    if (spec.length_encoding == FrameSpec::U16_TOTAL_LENGTH) {
+        const uint16_t total_be =
+            butil::HostToNet16(static_cast<uint16_t>(total_len));
+        frame->append(reinterpret_cast<const char*>(&total_be),
+                      sizeof(total_be));
+    } else if (spec.length_encoding == FrameSpec::U32_BODY_LENGTH) {
+        const uint32_t body_be =
+            butil::HostToNet32(static_cast<uint32_t>(payload.size()));
+        frame->append(reinterpret_cast<const char*>(&body_be),
+                      sizeof(body_be));
+    }
+    frame->append(payload);
+    return FRAME_OK;
+}
+
+FrameResult FrameCodec::ReadFrame(HandshakeIO* io, const FrameSpec& spec,
+                                  bool push_back_on_not_mine,
+                                  std::string* payload) {
+    if (io == NULL || payload == NULL ||
+        (spec.magic_len != 0 && spec.magic == NULL)) {
+        return FRAME_PROTOCOL_ERROR;
+    }
+
+    std::string header(spec.magic_len + LengthFieldSize(spec), '\0');
+    if (spec.magic_len != 0 &&
+        io->ReadExact(&header[0], spec.magic_len) < 0) {
+        return FRAME_IO_ERROR;
+    }
+    if (spec.magic_len != 0 &&
+        memcmp(header.data(), spec.magic, spec.magic_len) != 0) {
+        if (push_back_on_not_mine &&
+            io->PushBack(header.data(), spec.magic_len) < 0) {
+            return FRAME_IO_ERROR;
+        }
+        return FRAME_NOT_MINE;
+    }
+
+    const size_t length_size = LengthFieldSize(spec);
+    if (length_size != 0 &&
+        io->ReadExact(&header[spec.magic_len], length_size) < 0) {
+        return FRAME_IO_ERROR;
+    }
+    size_t frame_len = 0;
+    FrameResult result = DecodeLength(spec, header.data(), &frame_len);
+    if (result != FRAME_OK) {
+        return result;
+    }
+    const size_t body_len = frame_len - header.size();
+    payload->assign(body_len, '\0');
+    if (body_len != 0 && io->ReadExact(&(*payload)[0], body_len) < 0) {
+        return FRAME_IO_ERROR;
+    }
+    return FRAME_OK;
+}
+
+FrameResult FrameCodec::ParseBufferedFrame(HandshakeInput* input,
+                                           const FrameSpec& spec,
+                                           std::string* payload,
+                                           bool* magic_matched) {
+    if (magic_matched != NULL) {
+        *magic_matched = false;
+    }
+    if (input == NULL || payload == NULL ||
+        (spec.magic_len != 0 && spec.magic == NULL)) {
+        return FRAME_PROTOCOL_ERROR;
+    }
+    const size_t header_len = spec.magic_len + LengthFieldSize(spec);
+    if (input->Size() < spec.magic_len) {
+        return FRAME_NEED_MORE;
+    }
+    std::string header(header_len, '\0');
+    if (spec.magic_len != 0 &&
+        !input->CopyTo(&header[0], spec.magic_len)) {
+        return FRAME_NEED_MORE;
+    }
+    if (spec.magic_len != 0 &&
+        memcmp(header.data(), spec.magic, spec.magic_len) != 0) {
+        return FRAME_NOT_MINE;
+    }
+    if (magic_matched != NULL) {
+        *magic_matched = true;
+    }
+    if (input->Size() < header_len ||
+        (header_len != 0 && !input->CopyTo(&header[0], header_len))) {
+        return FRAME_NEED_MORE;
+    }
+    size_t frame_len = 0;
+    FrameResult result = DecodeLength(spec, header.data(), &frame_len);
+    if (result != FRAME_OK) {
+        return result;
+    }
+    if (input->Size() < frame_len) {
+        return FRAME_NEED_MORE;
+    }
+
+    std::string frame(frame_len, '\0');
+    if (!input->CopyTo(&frame[0], frame_len)) {
+        return FRAME_NEED_MORE;
+    }
+    if (!input->Consume(frame_len)) {
+        return FRAME_PROTOCOL_ERROR;
+    }
+    payload->assign(frame.data() + header_len, frame_len - header_len);
+    return FRAME_OK;
+}
+
+FrameResult FrameCodec::WriteFrame(HandshakeIO* io, const FrameSpec& spec,
+                                   const std::string& payload) {
+    if (io == NULL) {
+        return FRAME_PROTOCOL_ERROR;
+    }
+    std::string frame;
+    const FrameResult result = Encode(spec, payload, &frame);
+    if (result != FRAME_OK) {
+        return result;
+    }
+    return io->WriteAll(frame.data(), frame.size()) == 0
+        ? FRAME_OK : FRAME_IO_ERROR;
+}
+
+FrameResult FrameCodec::DrainFrame(HandshakeIO* io, const FrameSpec& spec) {
+    std::string ignored;
+    return ReadFrame(io, spec, false, &ignored);
+}
+
+}  // namespace handshake
+}  // namespace brpc
diff --git a/src/brpc/handshake/handshake_frame.h b/src/brpc/handshake/handshake_frame.h
new file mode 100644
index 0000000000..dbe399f738
--- /dev/null
+++ b/src/brpc/handshake/handshake_frame.h
@@ -0,0 +1,92 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#ifndef BRPC_HANDSHAKE_HANDSHAKE_FRAME_H
+#define BRPC_HANDSHAKE_HANDSHAKE_FRAME_H
+
+#include <cstddef>
+#include <string>
+
+#include "brpc/handshake/handshake_io.h"
+
+namespace brpc {
+namespace handshake {
+
+enum FrameResult {
+    FRAME_OK = 0,
+    FRAME_NOT_MINE,
+    FRAME_NEED_MORE,
+    FRAME_IO_ERROR,
+    FRAME_PROTOCOL_ERROR,
+};
+
+struct FrameSpec {
+    enum LengthEncoding {
+        FIXED,
+        U16_TOTAL_LENGTH,
+        U32_BODY_LENGTH,
+    };
+
+    FrameSpec()
+        : magic(NULL), magic_len(0), min_frame_len(0), max_frame_len(0),
+          length_encoding(FIXED) {}
+
+    FrameSpec(const char* magic_in, size_t magic_len_in,
+              size_t min_frame_len_in, size_t max_frame_len_in,
+              LengthEncoding length_encoding_in)
+        : magic(magic_in), magic_len(magic_len_in),
+          min_frame_len(min_frame_len_in),
+          max_frame_len(max_frame_len_in),
+          length_encoding(length_encoding_in) {}
+
+    const char* magic;
+    size_t magic_len;
+    size_t min_frame_len;
+    size_t max_frame_len;
+    LengthEncoding length_encoding;
+};
+
+// Handles only framing. Protocol implementations receive and produce payloads
+// after magic/length fields and remain responsible for their own business
+// fields and version semantics.
+class FrameCodec {
+public:
+    static FrameResult Encode(const FrameSpec& spec,
+                              const std::string& payload,
+                              std::string* frame);
+    static FrameResult ReadFrame(HandshakeIO* io, const FrameSpec& spec,
+                                 bool push_back_on_not_mine,
+                                 std::string* payload);
+    static FrameResult ParseBufferedFrame(HandshakeInput* input,
+                                          const FrameSpec& spec,
+                                          std::string* payload,
+                                          bool* magic_matched = NULL);
+    static FrameResult WriteFrame(HandshakeIO* io, const FrameSpec& spec,
+                                  const std::string& payload);
+    static FrameResult DrainFrame(HandshakeIO* io, const FrameSpec& spec);
+
+private:
+    static size_t LengthFieldSize(const FrameSpec& spec);
+    static FrameResult DecodeLength(const FrameSpec& spec,
+                                    const void* header,
+                                    size_t* frame_len);
+};
+
+}  // namespace handshake
+}  // namespace brpc
+
+#endif  // BRPC_HANDSHAKE_HANDSHAKE_FRAME_H
diff --git a/src/brpc/handshake/handshake_io.cpp b/src/brpc/handshake/handshake_io.cpp
new file mode 100644
index 0000000000..bf592d78ea
--- /dev/null
+++ b/src/brpc/handshake/handshake_io.cpp
@@ -0,0 +1,145 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "brpc/handshake/handshake_io.h"
+
+#include <cstdint>
+#include <errno.h>
+#include <unistd.h>
+
+#include "bthread/butex.h"
+#include "butil/time.h"
+#include "brpc/errno.pb.h"
+#include "brpc/socket.h"
+
+namespace brpc {
+namespace handshake {
+
+size_t IOBufHandshakeInput::Size() const {
+    return _source != NULL ? _source->size() : 0;
+}
+
+bool IOBufHandshakeInput::CopyTo(void* data, size_t len) const {
+    return _source != NULL && _source->copy_to(data, len) == len;
+}
+
+bool IOBufHandshakeInput::Consume(size_t len) {
+    return _source != NULL && _source->pop_front(len) == len;
+}
+
+static const int WAIT_TIMEOUT_MS = 50;
+
+SocketHandshakeIO::SocketHandshakeIO(Socket* socket)
+    : _socket(socket)
+    , _read_butex(bthread::butex_create_checked<butil::atomic<int> >()) {
+}
+
+SocketHandshakeIO::~SocketHandshakeIO() {
+    bthread::butex_destroy(_read_butex);
+}
+
+void SocketHandshakeIO::Reset(Socket* socket) {
+    _socket = socket;
+}
+
+void SocketHandshakeIO::NotifyReadable() {
+    _read_butex->fetch_add(1, butil::memory_order_release);
+    bthread::butex_wake(_read_butex);
+}
+
+template <typename ReadOnce>
+static int ReadExactLoop(butil::atomic<int>* read_butex,
+                         size_t len, ReadOnce read_once) {
+    size_t received = 0;
+    while (received < len) {
+        const int expected = read_butex->load(butil::memory_order_acquire);
+        const timespec duetime = butil::milliseconds_from_now(WAIT_TIMEOUT_MS);
+        const ssize_t nr = read_once(received, len - received);
+        if (nr < 0) {
+            if (errno != EAGAIN) {
+                return -1;
+            }
+            if (bthread::butex_wait(read_butex, expected, &duetime) < 0 &&
+                errno != EWOULDBLOCK && errno != ETIMEDOUT) {
+                return -1;
+            }
+        } else if (nr == 0) {
+            errno = EEOF;
+            return -1;
+        } else {
+            received += nr;
+        }
+    }
+    return 0;
+}
+
+int SocketHandshakeIO::ReadExact(void* data, size_t len) {
+    CHECK(data != NULL);
+    CHECK(_socket != NULL);
+    const int fd = _socket->fd();
+    return ReadExactLoop(_read_butex, len,
+        [data, fd](size_t offset, size_t remaining) {
+            return read(fd, static_cast<uint8_t*>(data) + offset, remaining);
+        });
+}
+
+template <typename WriteOnce>
+static int WriteAllLoop(Socket* socket, size_t len, WriteOnce write_once) {
+    size_t written = 0;
+    while (written < len) {
+        const timespec duetime = butil::milliseconds_from_now(WAIT_TIMEOUT_MS);
+        const ssize_t nw = write_once(written, len - written);
+        if (nw > 0) {
+            written += nw;
+            continue;
+        }
+        if (nw == 0) {
+            errno = EPIPE;
+            return -1;
+        }
+        if (errno != EAGAIN) {
+            return -1;
+        }
+        if (socket->WaitEpollOut(socket->fd(), true, &duetime) < 0 &&
+            errno != ETIMEDOUT) {
+            return -1;
+        }
+    }
+    return 0;
+}
+
+int SocketHandshakeIO::WriteAll(const void* data, size_t len) {
+    CHECK(data != NULL);
+    CHECK(_socket != NULL);
+    const int fd = _socket->fd();
+    return WriteAllLoop(_socket, len,
+        [data, fd](size_t offset, size_t remaining) {
+            return write(fd, static_cast<const uint8_t*>(data) + offset,
+                         remaining);
+        });
+}
+
+int SocketHandshakeIO::PushBack(const void* data, size_t len) {
+    CHECK(_socket != NULL);
+    if (len != 0) {
+        return _socket->_read_buf.append(data, len) == 0 ? 0 : -1;
+    }
+    return 0;
+}
+
+}  // namespace handshake
+}  // namespace brpc
diff --git a/src/brpc/handshake/handshake_io.h b/src/brpc/handshake/handshake_io.h
new file mode 100644
index 0000000000..82f83ab5cd
--- /dev/null
+++ b/src/brpc/handshake/handshake_io.h
@@ -0,0 +1,89 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#ifndef BRPC_HANDSHAKE_HANDSHAKE_IO_H
+#define BRPC_HANDSHAKE_HANDSHAKE_IO_H
+
+#include <cstddef>
+
+#include "butil/atomicops.h"
+#include "butil/iobuf.h"
+#include "butil/macros.h"
+
+namespace brpc {
+
+class Socket;
+
+namespace handshake {
+
+// Blocking byte-stream interface used by client handshakes and by protocols
+// whose server handshake still runs in a dedicated bthread.
+class HandshakeIO {
+public:
+    virtual ~HandshakeIO() = default;
+
+    virtual int ReadExact(void* data, size_t len) = 0;
+    virtual int WriteAll(const void* data, size_t len) = 0;
+    virtual int PushBack(const void* data, size_t len) = 0;
+};
+
+// Non-blocking input used by the standard InputMessenger parser path.
+// Consume is called only after a complete frame has been validated.
+class HandshakeInput {
+public:
+    virtual ~HandshakeInput() = default;
+
+    virtual size_t Size() const = 0;
+    virtual bool CopyTo(void* data, size_t len) const = 0;
+    virtual bool Consume(size_t len) = 0;
+};
+
+class IOBufHandshakeInput : public HandshakeInput {
+public:
+    explicit IOBufHandshakeInput(butil::IOBuf* source) : _source(source) {}
+
+    size_t Size() const override;
+    bool CopyTo(void* data, size_t len) const override;
+    bool Consume(size_t len) override;
+
+private:
+    butil::IOBuf* _source;
+};
+
+class SocketHandshakeIO : public HandshakeIO {
+public:
+    explicit SocketHandshakeIO(Socket* socket = NULL);
+    ~SocketHandshakeIO() override;
+
+    void Reset(Socket* socket);
+    void NotifyReadable();
+
+    int ReadExact(void* data, size_t len) override;
+    int WriteAll(const void* data, size_t len) override;
+    int PushBack(const void* data, size_t len) override;
+
+private:
+    Socket* _socket;
+    butil::atomic<int>* _read_butex;
+
+    DISALLOW_COPY_AND_ASSIGN(SocketHandshakeIO);
+};
+
+}  // namespace handshake
+}  // namespace brpc
+
+#endif  // BRPC_HANDSHAKE_HANDSHAKE_IO_H
diff --git a/src/brpc/rdma_handshake.cpp b/src/brpc/rdma_handshake.cpp
index 2e7edd2fa5..8999e810b2 100644
--- a/src/brpc/rdma_handshake.cpp
+++ b/src/brpc/rdma_handshake.cpp
@@ -18,18 +18,16 @@
 #if BRPC_WITH_RDMA
 
 #include "brpc/rdma_handshake.h"
-#include "brpc/rdma_handshake_constants.h"
 
-#include <string.h>
-#include <algorithm>            // std::min
-#include <string>
+#include <errno.h>
+#include <cstring>
 #include <limits>
+#include <string>
+
 #include <gflags/gflags.h>
-#include "butil/iobuf.h"        // IOBuf, IOPortal, IOBufAsZeroCopy*Stream
+
+#include "butil/raw_pack.h"
 #include "butil/sys_byteorder.h"
-#include "butil/raw_pack.h"      // RawPacker, RawUnpacker
-#include "brpc/socket.h"
-#include "brpc/rdma/rdma_endpoint.h"
 #include "brpc/rdma_handshake.pb.h"
 
 namespace brpc {
@@ -46,10 +44,8 @@ extern const uint16_t MIN_QP_SIZE;
 extern const uint16_t MIN_BLOCK_SIZE;
 extern bool g_skip_rdma_init;
 
-DEFINE_bool(rdma_ece, false, "Enable end-to-end ECE (Enhanced Connection Establishment) "
-                             "negotiation in the RDMA v3 handshake. Automatically degrades "
-                             "to no-ECE when the peer, the local libibverbs, or set_ece "
-                             "does not support it. Acts as a kill switch (default off).");
+DEFINE_bool(rdma_ece, false,
+            "Enable end-to-end ECE negotiation in the RDMA v3 handshake");
 
 void RdmaHandshakeAdapter::FillLocalHello(ParsedHello* local) const {
     _ep->GetLocalConnectionInfo(local);
@@ -69,9 +65,39 @@ void RdmaHandshakeAdapter::PrepareClientEce() {
     }
 }
 
-namespace v2_wire {
+handshake::HandshakeCodec RdmaHandshakeAdapter::MakeCodec(
+    ParsedHello* remote) {
+    handshake::HandshakeCodec codec{};
+    codec.protocol_version = ProtocolVersion();
+    codec.hello_frame = HelloFrameSpec();
+    codec.ack_frame = RdmaAckFrameSpec();
+    codec.build_hello = [this](bool enabled, std::string* payload) {
+        return BuildLocalHello(enabled, payload);
+    };
+    codec.parse_hello = [this, remote](const std::string& payload) {
+        return ParseRemoteHello(payload, remote);
+    };
+    codec.build_ack = [](bool enabled, std::string* payload) {
+        const uint32_t flags_be = butil::HostToNet32(
+            enabled ? HELLO_ACK_RDMA_OK : 0);
+        payload->assign(reinterpret_cast<const char*>(&flags_be),
+                        sizeof(flags_be));
+        return handshake::STEP_OK;
+    };
+    codec.parse_ack = [](const std::string& payload, bool* enabled) {
+        if (payload.size() != HELLO_ACK_LEN) {
+            errno = EPROTO;
+            return handshake::STEP_ERROR;
+        }
+        uint32_t flags_be = 0;
+        memcpy(&flags_be, payload.data(), sizeof(flags_be));
+        *enabled = (butil::NetToHost32(flags_be) & HELLO_ACK_RDMA_OK) != 0;
+        return handshake::STEP_OK;
+    };
+    return codec;
+}
 
-int DrainBytes(handshake::SocketHandshakeIO* io, size_t n);
+namespace v2_wire {
 
 void HelloMessage::Serialize(void* data) const {
     butil::RawPacker(data)
@@ -82,12 +108,11 @@ void HelloMessage::Serialize(void* data) const {
         .pack16(sq_size)
         .pack16(rq_size)
         .pack16(lid)
-        // gid is a raw 16-byte identifier and must NOT be byte-swapped.
         .pack_bytes(gid.raw, sizeof(gid.raw))
         .pack32(qp_num);
 }
 
-void HelloMessage::Deserialize(void* data) {
+void HelloMessage::Deserialize(const void* data) {
     butil::RawUnpacker(data)
         .unpack16(msg_len)
         .unpack16(hello_ver)
@@ -96,7 +121,6 @@ void HelloMessage::Deserialize(void* data) {
         .unpack16(sq_size)
         .unpack16(rq_size)
         .unpack16(lid)
-        // gid is a raw 16-byte identifier and must NOT be byte-swapped.
         .unpack_bytes(gid.raw, sizeof(gid.raw))
         .unpack32(qp_num);
 }
@@ -109,7 +133,7 @@ static bool ValidHelloMessage(const HelloMessage& msg) {
            msg.rq_size >= MIN_QP_SIZE;
 }
 
-static void TranslateV2Hello(const HelloMessage& msg, ParsedHello* out) {
+static void TranslateHello(const HelloMessage& msg, ParsedHello* out) {
     out->block_size = msg.block_size;
     out->sq_size = msg.sq_size;
     out->rq_size = msg.rq_size;
@@ -118,190 +142,115 @@ static void TranslateV2Hello(const HelloMessage& msg, ParsedHello* out) {
     out->qp_num = msg.qp_num;
 }
 
-RemoteHelloResult ReadBodyAndNegotiate(handshake::SocketHandshakeIO* io,
-                                       ParsedHello* remote) {
-    uint8_t data[HELLO_V2_MSG_LEN_MIN];
-    if (io->ReadExact(data, HELLO_V2_MSG_LEN_MIN - HELLO_MAGIC_LEN) < 0) {
-        return RemoteHelloResult::ERROR;
-    }
-    HelloMessage remote_msg{};
-    remote_msg.Deserialize(data);
-    if (remote_msg.msg_len < HELLO_V2_MSG_LEN_MIN ||
-        remote_msg.msg_len > HELLO_V2_MSG_LEN_MAX) {
-        errno = EPROTO;
-        return RemoteHelloResult::ERROR;
-    }
-    if (remote_msg.msg_len > HELLO_V2_MSG_LEN_MIN) {
-        // Drain unknown trailing bytes so they don't pollute subsequent
-        // reads (e.g. the upcoming ACK message). v2 base fields already
-        // carry enough information for negotiation; unknown trailing
-        // bytes are treated as optional hints that v2 safely ignores.
-        size_t ext_len = remote_msg.msg_len - HELLO_V2_MSG_LEN_MIN;
-        if (DrainBytes(io, ext_len) < 0) {
-            return RemoteHelloResult::ERROR;
-        }
-    }
-    if (!ValidHelloMessage(remote_msg)) {
-        return RemoteHelloResult::FALLBACK;
-    }
-    TranslateV2Hello(remote_msg, remote);
-    return RemoteHelloResult::NEGOTIATED;
+static void FillMessage(const ParsedHello& local, HelloMessage* msg) {
+    msg->msg_len = HELLO_V2_MSG_LEN_MIN;
+    msg->hello_ver = HELLO_V2_VERSION;
+    msg->impl_ver = IMPL_V2_VERSION;
+    msg->block_size = local.block_size;
+    msg->sq_size = local.sq_size;
+    msg->rq_size = local.rq_size;
+    msg->lid = local.lid;
+    msg->gid = local.gid;
+    msg->qp_num = local.qp_num;
 }
 
-int DrainBytes(handshake::SocketHandshakeIO* io, size_t n) {
-    uint8_t scratch[64];
-    while (n > 0) {
-        size_t chunk = std::min(n, sizeof(scratch));
-        if (io->ReadExact(scratch, chunk) < 0) {
-            return -1;
-        }
-        n -= chunk;
-    }
-    return 0;
+static handshake::StepResult SerializePayload(
+    const HelloMessage& msg, std::string* payload) {
+    uint8_t body[HELLO_V2_MSG_LEN_MIN - HELLO_MAGIC_LEN];
+    msg.Serialize(body);
+    // FrameCodec owns msg_len, so the protocol payload starts after it.
+    payload->assign(reinterpret_cast<const char*>(body + sizeof(uint16_t)),
+                    sizeof(body) - sizeof(uint16_t));
+    return handshake::STEP_OK;
+}
+
+static handshake::StepResult ParsePayload(
+    const std::string& payload, ParsedHello* remote) {
+    const size_t base_payload_len =
+        HELLO_V2_MSG_LEN_MIN - HELLO_MAGIC_LEN - sizeof(uint16_t);
+    if (payload.size() < base_payload_len) {
+        errno = EPROTO;
+        return handshake::STEP_ERROR;
+    }
+    uint8_t body[HELLO_V2_MSG_LEN_MIN - HELLO_MAGIC_LEN];
+    const uint16_t total_be = butil::HostToNet16(
+        static_cast<uint16_t>(HELLO_MAGIC_LEN + sizeof(uint16_t) +
+                              payload.size()));
+    memcpy(body, &total_be, sizeof(total_be));
+    memcpy(body + sizeof(total_be), payload.data(), base_payload_len);
+
+    HelloMessage msg{};
+    msg.Deserialize(body);
+    if (!ValidHelloMessage(msg)) {
+        return handshake::STEP_FALLBACK;
+    }
+    TranslateHello(msg, remote);
+    return handshake::STEP_OK;
 }
 
 }  // namespace v2_wire
 
-int RdmaClientHandshakeAdapterV2::SendLocalHello(bool enabled) {
+const handshake::FrameSpec&
+RdmaClientHandshakeAdapterV2::HelloFrameSpec() const {
+    return RdmaHelloFrameSpec(2);
+}
+
+handshake::StepResult RdmaClientHandshakeAdapterV2::BuildLocalHello(
+    bool enabled, std::string* payload) {
     CHECK(enabled);
-    uint8_t data[HELLO_V2_MSG_LEN_MIN];
     ParsedHello local{};
     FillLocalHello(&local);
-
-    v2_wire::HelloMessage local_msg{};
-    local_msg.msg_len = HELLO_V2_MSG_LEN_MIN;
-    local_msg.hello_ver = HELLO_V2_VERSION;
-    local_msg.impl_ver = IMPL_V2_VERSION;
-    local_msg.block_size = local.block_size;
-    local_msg.sq_size = local.sq_size;
-    local_msg.rq_size = local.rq_size;
-    local_msg.lid = local.lid;
-    local_msg.gid = local.gid;
-    local_msg.qp_num = local.qp_num;
-    fast_memcpy(data, HELLO_MAGIC, 4);
-    local_msg.Serialize((char*)data + 4);
-    return _io->WriteAll(data, HELLO_V2_MSG_LEN_MIN);
+    v2_wire::HelloMessage msg{};
+    v2_wire::FillMessage(local, &msg);
+    return v2_wire::SerializePayload(msg, payload);
 }
 
-RemoteHelloResult
-RdmaClientHandshakeAdapterV2::ReceiveAndParseRemoteHello(
-    ParsedHello* remote) {
-    uint8_t magic[HELLO_MAGIC_LEN];
-    if (_io->ReadExact(magic, HELLO_MAGIC_LEN) < 0) {
-        return RemoteHelloResult::ERROR;
-    }
-    if (memcmp(magic, HELLO_MAGIC, HELLO_MAGIC_LEN) != 0) {
-        errno = EPROTO;
-        return RemoteHelloResult::ERROR;
-    }
-
-    return v2_wire::ReadBodyAndNegotiate(_io, remote);
+handshake::StepResult RdmaClientHandshakeAdapterV2::ParseRemoteHello(
+    const std::string& payload, ParsedHello* remote) {
+    return v2_wire::ParsePayload(payload, remote);
 }
 
-// Parse one complete v2 client hello out of `_source` (non-blocking).
-// v2 hello: [ "RDMA" 4B ][ msg_len 2B ][ 34B ... ], base total = 40B.
-RemoteHelloResult
-RdmaServerHandshakeAdapterV2::ReceiveAndParseRemoteHello(
-    ParsedHello* remote) {
-    butil::IOBuf* source = _source;
-    constexpr size_t HDR_LEN = HELLO_MAGIC_LEN + 2;
-    if (source->size() < HDR_LEN) {
-        // msg_len has not fully arrived yet.
-        return RemoteHelloResult::NEED_MORE;
-    }
-
-    uint8_t hdr[HDR_LEN];
-    CHECK_EQ(source->copy_to(hdr, sizeof(hdr)), sizeof(hdr));
-
-    uint16_t msg_len = 0;
-    butil::RawUnpacker(hdr + HELLO_MAGIC_LEN).unpack16(msg_len);
-    if (msg_len < HELLO_V2_MSG_LEN_MIN || msg_len > HELLO_V2_MSG_LEN_MAX) {
-        errno = EPROTO;
-        return RemoteHelloResult::ERROR;
-    }
-    if (source->size() < msg_len) {
-        // Full message has not fully arrived yet.
-        return RemoteHelloResult::NEED_MORE;
-    }
-
-    // Consume the whole hello: magic + 36B base body + optional extension.
-    CHECK_EQ(source->pop_front(HELLO_MAGIC_LEN), HELLO_MAGIC_LEN);
-    uint8_t body[HELLO_V2_MSG_LEN_MIN - HELLO_MAGIC_LEN];  // 36B
-    CHECK_EQ(source->cutn(body, sizeof(body)), sizeof(body));
-    const size_t extension_len = msg_len - HELLO_V2_MSG_LEN_MIN;
-    if (extension_len != 0) {
-        // Consume only this frame's optional extension. A coalesced ACK or RPC
-        // belongs to the next parser stage and must remain in source.
-        CHECK_EQ(source->pop_front(extension_len), extension_len);
-    }
-
-    v2_wire::HelloMessage remote_msg{};
-    remote_msg.Deserialize(body);
-    if (!v2_wire::ValidHelloMessage(remote_msg)) {
-        return RemoteHelloResult::FALLBACK;
-    }
-    v2_wire::TranslateV2Hello(remote_msg, remote);
-    return RemoteHelloResult::NEGOTIATED;
+const handshake::FrameSpec&
+RdmaServerHandshakeAdapterV2::HelloFrameSpec() const {
+    return RdmaHelloFrameSpec(2);
 }
 
-int RdmaServerHandshakeAdapterV2::SendLocalHello(bool enabled) {
-    uint8_t data[HELLO_V2_MSG_LEN_MIN];
-    v2_wire::HelloMessage local_msg{};
-    local_msg.msg_len = HELLO_V2_MSG_LEN_MIN;
-    if (!enabled) {
-        local_msg.hello_ver = 0;
-        local_msg.impl_ver = 0;
-        local_msg.block_size = 0;
-        local_msg.sq_size = 0;
-        local_msg.rq_size = 0;
-        local_msg.lid = 0;
-        memset(local_msg.gid.raw, 0, sizeof(local_msg.gid.raw));
-        local_msg.qp_num     = 0;
-    } else {
+handshake::StepResult RdmaServerHandshakeAdapterV2::BuildLocalHello(
+    bool enabled, std::string* payload) {
+    v2_wire::HelloMessage msg{};
+    msg.msg_len = HELLO_V2_MSG_LEN_MIN;
+    if (enabled) {
         ParsedHello local{};
         FillLocalHello(&local);
-        local_msg.hello_ver = HELLO_V2_VERSION;
-        local_msg.impl_ver = IMPL_V2_VERSION;
-        local_msg.block_size = local.block_size;
-        local_msg.sq_size = local.sq_size;
-        local_msg.rq_size = local.rq_size;
-        local_msg.lid = local.lid;
-        local_msg.gid = local.gid;
-        local_msg.qp_num = local.qp_num;
+        v2_wire::FillMessage(local, &msg);
     }
-    fast_memcpy(data, HELLO_MAGIC, 4);
-    local_msg.Serialize((char*)data + 4);
-    return _io->WriteAll(data, HELLO_V2_MSG_LEN_MIN);
+    return v2_wire::SerializePayload(msg, payload);
+}
+
+handshake::StepResult RdmaServerHandshakeAdapterV2::ParseRemoteHello(
+    const std::string& payload, ParsedHello* remote) {
+    return v2_wire::ParsePayload(payload, remote);
 }
 
 namespace v3_wire {
 
-bool ValidRdmaHello(const RdmaHello& msg) {
+static bool ValidRdmaHello(const RdmaHello& msg) {
     if (msg.gid().size() != sizeof(ibv_gid)) {
         return false;
     }
-    // ParsedHello stores these as uint16_t; reject values that would truncate.
-    constexpr uint16_t MAX_UINT16 = std::numeric_limits<uint16_t>::max();
-    if (msg.sq_size() > MAX_UINT16 || msg.rq_size() > MAX_UINT16 || msg.lid() > MAX_UINT16) {
-        return false;
-    }
-    if (msg.block_size() < MIN_BLOCK_SIZE) {
+    const uint16_t max_uint16 = std::numeric_limits<uint16_t>::max();
+    if (msg.sq_size() > max_uint16 || msg.rq_size() > max_uint16 ||
+        msg.lid() > max_uint16) {
         return false;
     }
-    if (msg.sq_size() < MIN_QP_SIZE) {
+    if (msg.block_size() < MIN_BLOCK_SIZE || msg.sq_size() < MIN_QP_SIZE ||
+        msg.rq_size() < MIN_QP_SIZE) {
         return false;
     }
-    if (msg.rq_size() < MIN_QP_SIZE) {
-        return false;
-    }
-    // qp_num == 0 only happens in UT (no real QP allocated).
-    if (msg.qp_num() == 0 && !g_skip_rdma_init) {
-        return false;
-    }
-    return true;
+    return msg.qp_num() != 0 || g_skip_rdma_init;
 }
 
-void FillLocalRdmaHello(const ParsedHello& local, RdmaHello* msg) {
+static void FillLocalRdmaHello(const ParsedHello& local, RdmaHello* msg) {
     msg->set_block_size(local.block_size);
     msg->set_sq_size(local.sq_size);
     msg->set_rq_size(local.rq_size);
@@ -309,16 +258,6 @@ void FillLocalRdmaHello(const ParsedHello& local, RdmaHello* msg) {
     msg->set_gid(reinterpret_cast<const char*>(local.gid.raw),
                  sizeof(local.gid.raw));
     msg->set_qp_num(local.qp_num);
-
-    // Advertise ECE only when enabled. Role-dependent payload:
-    //   Client hello: the locally queried ECE capabilities;
-    //   Server hello: the reduced/negotiated ECE queried after RTS.
-    // When the relevant ECE is not valid (disabled, unsupported, or query
-    // failed) the field is simply omitted and the peer degrades to no-ECE.
-    // Advertise ECE if there is anything to advertise. The endpoint pre-fills
-    // _outgoing_ece in a role-specific way: client side stores its locally
-    // queried capabilities; server side stores the reduced/negotiated ECE
-    // after RTS. nullopt -> omit the field (peer degrades to no-ECE).
     if (FLAGS_rdma_ece && local.ece.has_value()) {
         RdmaEce* ece = msg->mutable_ece();
         ece->set_vendor_id(local.ece->vendor_id);
@@ -327,53 +266,7 @@ void FillLocalRdmaHello(const ParsedHello& local, RdmaHello* msg) {
     }
 }
 
-int ReadAndParseV3Hello(handshake::SocketHandshakeIO* io, RdmaHello* out) {
-    uint8_t size_buf[HELLO_V3_PB_SIZE_LEN];
-    if (io->ReadExact(size_buf, HELLO_V3_PB_SIZE_LEN) < 0) {
-        return -1;
-    }
-    uint32_t pb_size = butil::NetToHost32(
-        *reinterpret_cast<const uint32_t*>(size_buf));
-    if (pb_size == 0 || pb_size > HELLO_V3_MAX_PB_SIZE) {
-        errno = EPROTO;
-        return -1;
-    }
-    butil::IOPortal body;
-    if (io->ReadExact(&body, pb_size) < 0) {
-        return -1;
-    }
-
-    butil::IOBufAsZeroCopyInputStream input(body);
-    if (!out->ParseFromZeroCopyStream(&input)) {
-        LOG(ERROR) << "Failed to parse RdmaHello";
-        errno = EPROTO;
-        return -1;
-    }
-    return 0;
-}
-
-int WriteV3Hello(handshake::SocketHandshakeIO* io, const RdmaHello& msg) {
-    uint32_t pb_size = static_cast<uint32_t>(msg.ByteSizeLong());
-    if (pb_size > HELLO_V3_MAX_PB_SIZE) {
-        errno = EPROTO;
-        return -1;
-    }
-
-    // [ "RDM3" 4B ][ pb_size 4B (big-endian) ][ RdmaHello protobuf bytes ]
-    butil::IOBuf packet;
-    packet.append(HELLO_MAGIC_V3, HELLO_MAGIC_LEN);
-    uint32_t pb_size_be = butil::HostToNet32(pb_size);
-    packet.append(&pb_size_be, HELLO_V3_PB_SIZE_LEN);
-    butil::IOBufAsZeroCopyOutputStream output(&packet);
-    if (!msg.SerializeToZeroCopyStream(&output)) {
-        LOG(ERROR) << "Failed to serialize RdmaHello";
-        errno = EPROTO;
-        return -1;
-    }
-    return io->WriteAll(&packet);
-}
-
-void TranslateHello(const RdmaHello& msg, ParsedHello* out) {
+static void TranslateHello(const RdmaHello& msg, ParsedHello* out) {
     out->block_size = msg.block_size();
     out->sq_size = static_cast<uint16_t>(msg.sq_size());
     out->rq_size = static_cast<uint16_t>(msg.rq_size());
@@ -383,138 +276,107 @@ void TranslateHello(const RdmaHello& msg, ParsedHello* out) {
     if (FLAGS_rdma_ece && msg.has_ece()) {
         ibv_ece ece;
         ece.vendor_id = msg.ece().vendor_id();
-        ece.options   = msg.ece().options();
+        ece.options = msg.ece().options();
         ece.comp_mask = msg.ece().comp_mask();
         out->ece = ece;
     }
 }
 
-}  // namespace v3_wire
-
-int RdmaClientHandshakeAdapterV3::SendLocalHello(bool enabled) {
-    CHECK(enabled);
-    // Query local ECE capabilities so they can be advertised in the client
-    // hello. v3-only. Best-effort: any failure or missing API just means we
-    // won't advertise ECE (the peer then degrades to no-ECE establishment).
-    PrepareClientEce();
-
-    ParsedHello local{};
-    FillLocalHello(&local);
-    RdmaHello local_msg{};
-    v3_wire::FillLocalRdmaHello(local, &local_msg);
-    return v3_wire::WriteV3Hello(_io, local_msg);
-}
-
-RemoteHelloResult
-RdmaClientHandshakeAdapterV3::ReceiveAndParseRemoteHello(
-    ParsedHello* remote) {
-    uint8_t magic[HELLO_MAGIC_LEN];
-    if (_io->ReadExact(magic, HELLO_MAGIC_LEN) < 0) {
-        return RemoteHelloResult::ERROR;
-    }
-    if (memcmp(magic, HELLO_MAGIC_V3, HELLO_MAGIC_LEN) != 0) {
+static handshake::StepResult SerializePayload(
+    const RdmaHello& msg, std::string* payload) {
+    if (!msg.SerializeToString(payload) ||
+        payload->size() > HELLO_V3_MAX_PB_SIZE) {
         errno = EPROTO;
-        return RemoteHelloResult::ERROR;
+        return handshake::STEP_ERROR;
     }
+    return handshake::STEP_OK;
+}
 
-    RdmaHello remote_msg{};
-    if (v3_wire::ReadAndParseV3Hello(_io, &remote_msg) < 0) {
-        return RemoteHelloResult::ERROR;
+static handshake::StepResult ParsePayload(
+    const std::string& payload, ParsedHello* remote) {
+    RdmaHello msg;
+    if (!msg.ParseFromArray(payload.data(), static_cast<int>(payload.size()))) {
+        errno = EPROTO;
+        return handshake::STEP_ERROR;
     }
-    if (!v3_wire::ValidRdmaHello(remote_msg)) {
-        return RemoteHelloResult::FALLBACK;
+    if (!ValidRdmaHello(msg)) {
+        return handshake::STEP_FALLBACK;
     }
-    v3_wire::TranslateHello(remote_msg, remote);
-    return RemoteHelloResult::NEGOTIATED;
+    TranslateHello(msg, remote);
+    return handshake::STEP_OK;
 }
 
-// Parse one complete v3 client hello out of `_source` (non-blocking).
-// v3 hello: [ "RDM3" 4B ][ pb_size 4B (big-endian) ][ RdmaHello ]
-RemoteHelloResult
-RdmaServerHandshakeAdapterV3::ReceiveAndParseRemoteHello(
-    ParsedHello* remote) {
-    constexpr size_t HDR_LEN = HELLO_MAGIC_LEN + HELLO_V3_PB_SIZE_LEN;
-    if (_source->size() < HDR_LEN) {
-        // pb_size has not fully arrived yet.
-        return RemoteHelloResult::NEED_MORE;
-    }
+static void FillDisabledHello(RdmaHello* msg) {
+    msg->set_block_size(0);
+    msg->set_sq_size(0);
+    msg->set_rq_size(0);
+    msg->set_lid(0);
+    msg->set_gid(std::string(sizeof(ibv_gid), '\0'));
+    msg->set_qp_num(0);
+}
 
-    uint8_t hdr[HDR_LEN];
-    CHECK_EQ(_source->copy_to(hdr, sizeof(hdr)), sizeof(hdr));
+}  // namespace v3_wire
 
-    uint32_t pb_size = butil::NetToHost32(
-        *reinterpret_cast<const uint32_t*>(hdr + HELLO_MAGIC_LEN));
-    if (pb_size == 0 || pb_size > HELLO_V3_MAX_PB_SIZE) {
-        errno = EPROTO;
-        return RemoteHelloResult::ERROR;
-    }
-    size_t total = HDR_LEN + pb_size;
-    if (_source->size() < total) {
-        // Full message has not fully arrived yet.
-        return RemoteHelloResult::NEED_MORE;
-    }
+const handshake::FrameSpec&
+RdmaClientHandshakeAdapterV3::HelloFrameSpec() const {
+    return RdmaHelloFrameSpec(3);
+}
 
-    CHECK_EQ(_source->cutn(hdr, HDR_LEN), HDR_LEN);
-    butil::IOBuf pb;
-    CHECK_EQ(_source->cutn(&pb, pb_size), pb_size);
-    RdmaHello remote_msg;
-    butil::IOBufAsZeroCopyInputStream input(pb);
-    if (!remote_msg.ParseFromZeroCopyStream(&input)) {
-        LOG(ERROR) << "Failed to parse RdmaHello";
-        errno = EPROTO;
-        return RemoteHelloResult::ERROR;
-    }
-    if (!v3_wire::ValidRdmaHello(remote_msg)) {
-        return RemoteHelloResult::FALLBACK;
-    }
-    v3_wire::TranslateHello(remote_msg, remote);
-    return RemoteHelloResult::NEGOTIATED;
+handshake::StepResult RdmaClientHandshakeAdapterV3::BuildLocalHello(
+    bool enabled, std::string* payload) {
+    CHECK(enabled);
+    PrepareClientEce();
+    ParsedHello local{};
+    FillLocalHello(&local);
+    RdmaHello msg;
+    v3_wire::FillLocalRdmaHello(local, &msg);
+    return v3_wire::SerializePayload(msg, payload);
 }
 
-int RdmaServerHandshakeAdapterV3::SendLocalHello(bool enabled) {
-    RdmaHello local_msg{};
-    if (!enabled) {
-        // Un-negotiable hello: all body fields are zero so the client's
-        // rejects it and downgrades to TCP on the same connection.
-        local_msg.set_block_size(0);
-        local_msg.set_sq_size(0);
-        local_msg.set_rq_size(0);
-        local_msg.set_lid(0);
-        local_msg.set_gid(std::string(sizeof(ibv_gid), '\0'));
-        local_msg.set_qp_num(0);
-    } else {
+handshake::StepResult RdmaClientHandshakeAdapterV3::ParseRemoteHello(
+    const std::string& payload, ParsedHello* remote) {
+    return v3_wire::ParsePayload(payload, remote);
+}
+
+const handshake::FrameSpec&
+RdmaServerHandshakeAdapterV3::HelloFrameSpec() const {
+    return RdmaHelloFrameSpec(3);
+}
+
+handshake::StepResult RdmaServerHandshakeAdapterV3::BuildLocalHello(
+    bool enabled, std::string* payload) {
+    RdmaHello msg;
+    if (enabled) {
         ParsedHello local{};
         FillLocalHello(&local);
-        v3_wire::FillLocalRdmaHello(local, &local_msg);
+        v3_wire::FillLocalRdmaHello(local, &msg);
+    } else {
+        v3_wire::FillDisabledHello(&msg);
     }
-    return v3_wire::WriteV3Hello(_io, local_msg);
+    return v3_wire::SerializePayload(msg, payload);
+}
+
+handshake::StepResult RdmaServerHandshakeAdapterV3::ParseRemoteHello(
+    const std::string& payload, ParsedHello* remote) {
+    return v3_wire::ParsePayload(payload, remote);
 }
 
 std::unique_ptr<RdmaHandshakeAdapter> CreateClientHandshakeAdapter(
-    RdmaEndpoint* ep, handshake::SocketHandshakeIO* io) {
-    switch (FLAGS_rdma_client_handshake_version) {
-    case 3:
-        return std::unique_ptr<RdmaHandshakeAdapter>(
-            new RdmaClientHandshakeAdapterV3(ep, io));
-    case 2:
-    default:
+    RdmaEndpoint* ep) {
+    if (FLAGS_rdma_client_handshake_version == 3) {
         return std::unique_ptr<RdmaHandshakeAdapter>(
-            new RdmaClientHandshakeAdapterV2(ep, io));
+            new RdmaClientHandshakeAdapterV3(ep));
     }
+    return std::unique_ptr<RdmaHandshakeAdapter>(
+        new RdmaClientHandshakeAdapterV2(ep));
 }
 
-std::unique_ptr<RdmaHandshakeAdapter> CreateServerHandshakeAdapterByMagic(
-    RdmaEndpoint* ep, handshake::SocketHandshakeIO* io, butil::IOBuf* source,
-    const uint8_t magic[HELLO_MAGIC_LEN]) {
-    if (memcmp(magic, HELLO_MAGIC, HELLO_MAGIC_LEN) == 0) {
-        return std::unique_ptr<RdmaHandshakeAdapter>(
-            new RdmaServerHandshakeAdapterV2(ep, io, source));
-    }
-    if (memcmp(magic, HELLO_MAGIC_V3, HELLO_MAGIC_LEN) == 0) {
-        return std::unique_ptr<RdmaHandshakeAdapter>(
-            new RdmaServerHandshakeAdapterV3(ep, io, source));
-    }
-    return NULL;
+std::vector<std::unique_ptr<RdmaHandshakeAdapter> >
+CreateServerHandshakeAdapters(RdmaEndpoint* ep) {
+    std::vector<std::unique_ptr<RdmaHandshakeAdapter> > adapters;
+    adapters.emplace_back(new RdmaServerHandshakeAdapterV2(ep));
+    adapters.emplace_back(new RdmaServerHandshakeAdapterV3(ep));
+    return adapters;
 }
 
 }  // namespace rdma
diff --git a/src/brpc/rdma_handshake.h b/src/brpc/rdma_handshake.h
index cb048cf046..67112c0afa 100644
--- a/src/brpc/rdma_handshake.h
+++ b/src/brpc/rdma_handshake.h
@@ -21,44 +21,27 @@
 #if BRPC_WITH_RDMA
 
 #include <memory>
+#include <string>
+#include <vector>
+
 #include <infiniband/verbs.h>
-#include "butil/macros.h"
+
 #include "butil/containers/optional.h"
+#include "butil/macros.h"
 #include "brpc/rdma/rdma_endpoint.h"
 #include "brpc/rdma_handshake_constants.h"
 #include "brpc/transport_handshake.h"
 
-namespace butil {
-class IOBuf;
-}
-
 namespace brpc {
 namespace rdma {
 
-// Wire-format-agnostic representation of a peer's hello message.
-// Each protocol version (v2 binary, v3 protobuf) translates its own
-// wire format into this struct so the state-machine driver in RdmaTransport
-// stays free of any wire-format details.
 using ParsedHello = RdmaConnectionInfo;
 
-// Result of reading/parsing a peer's hello (see ReceiveAndParseRemoteHello).
-enum class RemoteHelloResult {
-    // A full hello was read and negotiation succeeded.
-    NEGOTIATED,
-    // A full hello was read but negotiation failed.
-    FALLBACK,
-    // (server only) Not enough data yet.
-    NEED_MORE,
-    // IO/protocol error (errno set).
-    ERROR,
-};
-
 namespace v2_wire {
 
-// v2 binary HelloMessage.
 struct HelloMessage {
     void Serialize(void* data) const;
-    void Deserialize(void* data);
+    void Deserialize(const void* data);
 
     uint16_t msg_len;
     uint16_t hello_ver;
@@ -67,124 +50,89 @@ struct HelloMessage {
     uint16_t sq_size;
     uint16_t rq_size;
     uint16_t lid;
-    ibv_gid  gid;
+    ibv_gid gid;
     uint32_t qp_num;
 };
 
 }  // namespace v2_wire
 
-// Base class of an RDMA handshake, shared by both roles.
+// RDMA adapters implement only protocol fields. HandshakeSession owns frame
+// I/O, length validation, ACK exchange and resource callback ordering.
 class RdmaHandshakeAdapter {
 public:
-    RdmaHandshakeAdapter(
-        RdmaEndpoint* ep, handshake::SocketHandshakeIO* io, int version)
-        : _ep(ep), _io(io), _version(version) {}
+    RdmaHandshakeAdapter(RdmaEndpoint* ep, int version)
+        : _ep(ep), _version(version) {}
     virtual ~RdmaHandshakeAdapter() = default;
 
-    DISALLOW_COPY_AND_ASSIGN(RdmaHandshakeAdapter);
-
-    // Wire-level protocol version (2 for "RDMA", 3 for "RDM3").
     int ProtocolVersion() const { return _version; }
+    handshake::HandshakeCodec MakeCodec(ParsedHello* remote);
 
-    // Build and send the local hello (including the protocol magic).
-    // Returns 0 on success, -1 on IO error (errno set).
-    //
-    // For a server in fallback state, implementations MUST still
-    // produce a sendable message; each version uses its own wire
-    // convention to signal "I am falling back" to the peer:
-    //   - v2: zero hello_ver/impl_ver so the peer's HelloNegotiationValid
-    //         rejects it;
-    //   - v3: qp_num==0 so the peer's ValidRdmaHello rejects it.
-    virtual int SendLocalHello(bool enabled) = 0;
-
-    // Read and parse the peer's hello into *remote.
-    virtual RemoteHelloResult ReceiveAndParseRemoteHello(ParsedHello* remote) = 0;
+    virtual const handshake::FrameSpec& HelloFrameSpec() const = 0;
+    virtual handshake::StepResult BuildLocalHello(
+        bool enabled, std::string* payload) = 0;
+    virtual handshake::StepResult ParseRemoteHello(
+        const std::string& payload, ParsedHello* remote) = 0;
 
 protected:
-    // Translate the endpoint's local resource state into the wire-independent
-    // adapter representation. Endpoint internals never leak into the codec.
     void FillLocalHello(ParsedHello* local) const;
-
-    // Best-effort v3 client ECE preparation. Failure only disables ECE.
     void PrepareClientEce();
 
     RdmaEndpoint* _ep;
-    handshake::SocketHandshakeIO* _io;
     int _version;
-};
-
-// Server-side handshake base: parses the remote hello non-blockingly out of
-// `_source` (an IOBuf filled by InputMessenger), never touching the fd.
-class RdmaServerHandshakeAdapter : public RdmaHandshakeAdapter {
-public:
-    RdmaServerHandshakeAdapter(
-        RdmaEndpoint* ep, handshake::SocketHandshakeIO* io,
-        butil::IOBuf* source, int version)
-        : RdmaHandshakeAdapter(ep, io, version), _source(source) {}
 
-protected:
-    butil::IOBuf* _source;
+private:
+    DISALLOW_COPY_AND_ASSIGN(RdmaHandshakeAdapter);
 };
 
-// v2 handshake (legacy "RDMA" magic, 36B binary HelloMessage).
 class RdmaClientHandshakeAdapterV2 : public RdmaHandshakeAdapter {
 public:
-    RdmaClientHandshakeAdapterV2(
-        RdmaEndpoint* ep, handshake::SocketHandshakeIO* io)
-        : RdmaHandshakeAdapter(ep, io, 2) {}
-    int SendLocalHello(bool enabled) override;
-    RemoteHelloResult ReceiveAndParseRemoteHello(ParsedHello* remote) override;
+    explicit RdmaClientHandshakeAdapterV2(RdmaEndpoint* ep)
+        : RdmaHandshakeAdapter(ep, 2) {}
+    const handshake::FrameSpec& HelloFrameSpec() const override;
+    handshake::StepResult BuildLocalHello(
+        bool enabled, std::string* payload) override;
+    handshake::StepResult ParseRemoteHello(
+        const std::string& payload, ParsedHello* remote) override;
 };
 
-class RdmaServerHandshakeAdapterV2 : public RdmaServerHandshakeAdapter {
+class RdmaServerHandshakeAdapterV2 : public RdmaHandshakeAdapter {
 public:
-    RdmaServerHandshakeAdapterV2(
-        RdmaEndpoint* ep, handshake::SocketHandshakeIO* io,
-        butil::IOBuf* source)
-        : RdmaServerHandshakeAdapter(ep, io, source, 2) {}
-    int SendLocalHello(bool enabled) override;
-    RemoteHelloResult ReceiveAndParseRemoteHello(ParsedHello* remote) override;
+    explicit RdmaServerHandshakeAdapterV2(RdmaEndpoint* ep)
+        : RdmaHandshakeAdapter(ep, 2) {}
+    const handshake::FrameSpec& HelloFrameSpec() const override;
+    handshake::StepResult BuildLocalHello(
+        bool enabled, std::string* payload) override;
+    handshake::StepResult ParseRemoteHello(
+        const std::string& payload, ParsedHello* remote) override;
 };
 
-// v3 handshake (new "RDM3" magic, protobuf RdmaHello).
-// [ "RDM3" 4B ][ pb_size 4B (big-endian) ][ RdmaHello protobuf bytes ]
 class RdmaClientHandshakeAdapterV3 : public RdmaHandshakeAdapter {
 public:
-    RdmaClientHandshakeAdapterV3(
-        RdmaEndpoint* ep, handshake::SocketHandshakeIO* io)
-        : RdmaHandshakeAdapter(ep, io, 3) {}
-    int SendLocalHello(bool enabled) override;
-    RemoteHelloResult ReceiveAndParseRemoteHello(ParsedHello* remote) override;
+    explicit RdmaClientHandshakeAdapterV3(RdmaEndpoint* ep)
+        : RdmaHandshakeAdapter(ep, 3) {}
+    const handshake::FrameSpec& HelloFrameSpec() const override;
+    handshake::StepResult BuildLocalHello(
+        bool enabled, std::string* payload) override;
+    handshake::StepResult ParseRemoteHello(
+        const std::string& payload, ParsedHello* remote) override;
 };
 
-class RdmaServerHandshakeAdapterV3 : public RdmaServerHandshakeAdapter {
+class RdmaServerHandshakeAdapterV3 : public RdmaHandshakeAdapter {
 public:
-    RdmaServerHandshakeAdapterV3(
-        RdmaEndpoint* ep, handshake::SocketHandshakeIO* io,
-        butil::IOBuf* source)
-        : RdmaServerHandshakeAdapter(ep, io, source, 3) {}
-    int SendLocalHello(bool enabled) override;
-    RemoteHelloResult ReceiveAndParseRemoteHello(ParsedHello* remote) override;
+    explicit RdmaServerHandshakeAdapterV3(RdmaEndpoint* ep)
+        : RdmaHandshakeAdapter(ep, 3) {}
+    const handshake::FrameSpec& HelloFrameSpec() const override;
+    handshake::StepResult BuildLocalHello(
+        bool enabled, std::string* payload) override;
+    handshake::StepResult ParseRemoteHello(
+        const std::string& payload, ParsedHello* remote) override;
 };
 
-// Factory methods
-//
-// Pick the client-side handshake based on
-// FLAGS_rdma_client_handshake_version:
-//   2 (default) -> RdmaClientHandshakeAdapterV2
-//   3           -> RdmaClientHandshakeAdapterV3
-// Other values fall back to V2.
 std::unique_ptr<RdmaHandshakeAdapter> CreateClientHandshakeAdapter(
-    RdmaEndpoint* ep, handshake::SocketHandshakeIO* io);
-
-// Pick the server-side handshake based on the 4B magic already read.
-// Returns NULL if `magic` is not a recognized RDMA magic
-// (the caller should then fallback to TCP).
-//   "RDMA" -> RdmaServerHandshakeAdapterV2
-//   "RDM3" -> RdmaServerHandshakeAdapterV3
-std::unique_ptr<RdmaHandshakeAdapter> CreateServerHandshakeAdapterByMagic(
-    RdmaEndpoint* ep, handshake::SocketHandshakeIO* io, butil::IOBuf* source,
-    const uint8_t magic[HELLO_MAGIC_LEN]);
+    RdmaEndpoint* ep);
+
+std::vector<std::unique_ptr<RdmaHandshakeAdapter> >
+CreateServerHandshakeAdapters(RdmaEndpoint* ep);
 
 }  // namespace rdma
 }  // namespace brpc
diff --git a/src/brpc/rdma_handshake_constants.h b/src/brpc/rdma_handshake_constants.h
index c60c70f170..2041a5e2da 100644
--- a/src/brpc/rdma_handshake_constants.h
+++ b/src/brpc/rdma_handshake_constants.h
@@ -18,6 +18,11 @@
 #ifndef BRPC_RDMA_HANDSHAKE_CONSTANTS_H
 #define BRPC_RDMA_HANDSHAKE_CONSTANTS_H
 
+#include <cstddef>
+#include <cstdint>
+
+#include "brpc/handshake/handshake_frame.h"
+
 namespace brpc {
 namespace rdma {
 
@@ -50,6 +55,26 @@ constexpr size_t HELLO_V3_MAX_PB_SIZE = 8192;
 constexpr size_t HELLO_ACK_LEN = 4;
 constexpr uint32_t HELLO_ACK_RDMA_OK = 0x1;
 
+inline const handshake::FrameSpec& RdmaHelloFrameSpec(int version) {
+    static const handshake::FrameSpec v2(
+        HELLO_MAGIC, HELLO_MAGIC_LEN,
+        HELLO_V2_MSG_LEN_MIN, HELLO_V2_MSG_LEN_MAX,
+        handshake::FrameSpec::U16_TOTAL_LENGTH);
+    static const handshake::FrameSpec v3(
+        HELLO_MAGIC_V3, HELLO_MAGIC_LEN,
+        HELLO_MAGIC_LEN + HELLO_V3_PB_SIZE_LEN + 1,
+        HELLO_MAGIC_LEN + HELLO_V3_PB_SIZE_LEN + HELLO_V3_MAX_PB_SIZE,
+        handshake::FrameSpec::U32_BODY_LENGTH);
+    return version == 2 ? v2 : v3;
+}
+
+inline const handshake::FrameSpec& RdmaAckFrameSpec() {
+    static const handshake::FrameSpec spec(
+        NULL, 0, HELLO_ACK_LEN, HELLO_ACK_LEN,
+        handshake::FrameSpec::FIXED);
+    return spec;
+}
+
 }  // namespace rdma
 }  // namespace brpc
 
diff --git a/src/brpc/rdma_handshake_server.cpp b/src/brpc/rdma_handshake_server.cpp
index 68404ae28f..483156c8d6 100644
--- a/src/brpc/rdma_handshake_server.cpp
+++ b/src/brpc/rdma_handshake_server.cpp
@@ -17,16 +17,16 @@
 
 #include "brpc/rdma_handshake_server.h"
 
+#include <errno.h>
 #include <limits>
 #include <string>
-#include <string.h>
-#include "butil/iobuf.h"
-#include "butil/logging.h"
+
 #include "butil/raw_pack.h"
 #include "butil/sys_byteorder.h"
-#include "brpc/socket.h"
+#include "brpc/adapter_transport.h"
 #include "brpc/rdma_handshake.pb.h"
 #include "brpc/rdma_handshake_constants.h"
+#include "brpc/socket.h"
 #if BRPC_WITH_RDMA
 #include "brpc/rdma_transport.h"
 #endif
@@ -34,165 +34,103 @@
 namespace brpc {
 namespace rdma {
 
-// Fallback-only server handshake. Used for any connection that is NOT in RDMA
-// mode: builds without RDMA (no RdmaEndpoint exists at all), and RDMA-enabled
-// builds where this particular connection is plain TCP. Every RDMA client that
-// reaches here is answered with an un-negotiable hello and asked to downgrade
-// to TCP on the same connection, then its ACK is drained.
-
-// An intentionally-invalid v2 hello_ver: the client's ValidHelloMessage()
-// requires hello_ver==2, so it rejects this and falls back.
-static constexpr uint16_t V2_HELLO_VERSION_INVALID = std::numeric_limits<uint16_t>::max();
-// Length of the gid field (== sizeof(ibv_gid)), spelled as a literal so this
-// compile-switch-independent file stays free of <infiniband/verbs.h>.
+// Fallback-only field codecs for connections that do not own an
+// RdmaEndpoint. Framing, incremental input, ACK handling, and state are still
+// driven by HandshakeSession, exactly like the real RDMA server handshake.
+static constexpr uint16_t V2_HELLO_VERSION_INVALID =
+    std::numeric_limits<uint16_t>::max();
 static constexpr size_t V3_GID_LEN = 16;
 
-// Consume one complete v2 client hello ("RDMA" + 2B msg_len + body) from
-// `source` without interpreting its content (fallback does not negotiate).
-// Returns 1 (consumed), 0 (not enough data yet, nothing consumed) or -1 (error).
-static int DrainClientHelloV2(butil::IOBuf* source) {
-    constexpr size_t HDR_LEN = HELLO_MAGIC_LEN + 2;
-    if (source->size() < HDR_LEN) {
-        return 0;
-    }
-
-    uint8_t hdr[HDR_LEN];
-    CHECK_EQ(source->copy_to(hdr, sizeof(hdr)), sizeof(hdr));
-
-    uint16_t msg_len = 0;
-    butil::RawUnpacker(hdr + HELLO_MAGIC_LEN).unpack16(msg_len);
-    if (msg_len < HELLO_V2_MSG_LEN_MIN || msg_len > HELLO_V2_MSG_LEN_MAX) {
-        return -1;
-    }
-
-    if (source->size() < msg_len) {
-        return 0;
-    }
-
-    CHECK_EQ(source->pop_front(msg_len), msg_len);
-    return 1;
-}
-
-// Consume one complete v3 client hello ("RDM3" + 4B pb_size + protobuf body)
-// from `source` without interpreting its content.
-// Returns 1 (consumed), 0 (not enough data yet, nothing consumed) or -1 (error).
-static int DrainClientHelloV3(butil::IOBuf* source) {
-    constexpr size_t HDR_LEN = HELLO_MAGIC_LEN + HELLO_V3_PB_SIZE_LEN;
-    if (source->size()< HDR_LEN) {
-        return 0;
-    }
-
-    uint8_t hdr[HDR_LEN];
-    CHECK_EQ(source->copy_to(hdr, sizeof(hdr)), sizeof(hdr));
-
-    uint32_t pb_size = butil::NetToHost32(
-        *reinterpret_cast<const uint32_t*>(hdr + HELLO_MAGIC_LEN));
-    if (pb_size == 0 || pb_size > HELLO_V3_MAX_PB_SIZE) {
-        return -1;
-    }
-
-    const size_t total = HDR_LEN + pb_size;
-    if (source->size() < total) {
-        return 0;
-    }
-
-    CHECK_EQ(source->pop_front(total), total);
-    return 1;
-}
-
-// Reply an un-negotiable hello so the client downgrades to TCP. All body fields
-// are zero/invalid so the client's validity check rejects it.
-// Returns 0 on success, -1 otherwise.
-static int SendUnnegotiableHello(Socket* socket, int version) {
-    butil::IOBuf packet;
-    if (version == 2) {
-        // magic "RDMA" + msg_len(=40) + invalid hello_ver; rest stays zero.
-        // NOTE: msg_len is the length of the WHOLE hello INCLUDING the 4B magic
-        // (== HELLO_V2_MSG_LEN_MIN), not just the body; the client rejects any
-        // msg_len < HELLO_V2_MSG_LEN_MIN as a protocol error.
-        packet.append(HELLO_MAGIC, HELLO_MAGIC_LEN);
-        char reply[HELLO_V2_MSG_LEN_MIN - HELLO_MAGIC_LEN]{};
-        butil::RawPacker(reply).pack16(HELLO_V2_MSG_LEN_MIN)
-                               .pack16(V2_HELLO_VERSION_INVALID);
-        packet.append(reply, sizeof(reply));
-    } else {
-        // "RDM3" + pb_size + RdmaHello with block_size==0 & qp_num==0 so the
-        // client's ValidRdmaHello() returns false.
-        RdmaHello reply_msg;
-        reply_msg.set_block_size(0);
-        reply_msg.set_sq_size(0);
-        reply_msg.set_rq_size(0);
-        reply_msg.set_lid(0);
-        reply_msg.set_gid(std::string(V3_GID_LEN, '\0'));
-        reply_msg.set_qp_num(0);
-        packet.append(HELLO_MAGIC_V3, HELLO_MAGIC_LEN);
-        uint32_t pb_size_be =
-            butil::HostToNet32(static_cast<uint32_t>(reply_msg.ByteSizeLong()));
-        packet.append(&pb_size_be, sizeof(pb_size_be));
-        butil::IOBufAsZeroCopyOutputStream output(&packet);
-        if (!reply_msg.SerializeToZeroCopyStream(&output)) {
-            LOG(WARNING) << "Fail to serialize RDMA v3 fallback hello";
-            return -1;
+static handshake::HandshakeCodec MakeFallbackCodec(int version) {
+    handshake::HandshakeCodec codec{};
+    codec.protocol_version = version;
+    codec.hello_frame = RdmaHelloFrameSpec(version);
+    codec.ack_frame = RdmaAckFrameSpec();
+    codec.parse_hello = [](const std::string&) {
+        return handshake::STEP_FALLBACK;
+    };
+    codec.build_hello = [version](bool enabled, std::string* payload) {
+        if (enabled) {
+            errno = EPROTO;
+            return handshake::STEP_ERROR;
         }
-    }
-
-    if (socket->Write(&packet) != 0) {
-        PLOG(WARNING) << "Fail to send RDMA fallback hello to " << socket->description();
-        return -1;
-    }
-    return 0;
-}
-
-// Fallback handshake for connections that are NOT in RDMA mode.
-static ParseResult FallbackServerHandshake(butil::IOBuf* source, Socket* socket) {
-    if (socket->parsing_context() == NULL) {
-        if (source->size() < HELLO_MAGIC_LEN) {
-            return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
-        }
-        // Phase 1: consume the client hello and reply an un-negotiable hello.
-        uint8_t magic[HELLO_MAGIC_LEN];
-        CHECK_EQ(source->copy_to(magic, HELLO_MAGIC_LEN), HELLO_MAGIC_LEN);
-
-        int version;
-        if (memcmp(magic, HELLO_MAGIC, HELLO_MAGIC_LEN) == 0) {
-            version = 2;
-        } else if (memcmp(magic, HELLO_MAGIC_V3, HELLO_MAGIC_LEN) == 0) {
-            version = 3;
-        } else {
-            return MakeParseError(PARSE_ERROR_TRY_OTHERS);
+        if (version == 2) {
+            // FrameCodec emits magic and msg_len. The protocol payload starts
+            // at hello_ver and deliberately advertises an invalid version.
+            payload->assign(
+                HELLO_V2_MSG_LEN_MIN - HELLO_MAGIC_LEN - sizeof(uint16_t),
+                '\0');
+            butil::RawPacker(&(*payload)[0])
+                .pack16(V2_HELLO_VERSION_INVALID);
+            return handshake::STEP_OK;
         }
 
-        const int r = version == 2 ? DrainClientHelloV2(source) : DrainClientHelloV3(source);
-        if (r == 0) {
-            // Hello not complete yet; keep the buffer intact and retry later.
-            return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
-        }
-        if (r < 0) {
-            return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
+        RdmaHello reply;
+        reply.set_block_size(0);
+        reply.set_sq_size(0);
+        reply.set_rq_size(0);
+        reply.set_lid(0);
+        reply.set_gid(std::string(V3_GID_LEN, '\0'));
+        reply.set_qp_num(0);
+        if (!reply.SerializeToString(payload)) {
+            errno = EPROTO;
+            return handshake::STEP_ERROR;
         }
-        if (SendUnnegotiableHello(socket, version) < 0) {
-            return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
+        return handshake::STEP_OK;
+    };
+    codec.build_ack = [](bool enabled, std::string* payload) {
+        const uint32_t flags_be = butil::HostToNet32(
+            enabled ? HELLO_ACK_RDMA_OK : 0);
+        payload->assign(reinterpret_cast<const char*>(&flags_be),
+                        sizeof(flags_be));
+        return handshake::STEP_OK;
+    };
+    codec.parse_ack = [](const std::string& payload, bool* enabled) {
+        if (payload.size() != HELLO_ACK_LEN) {
+            errno = EPROTO;
+            return handshake::STEP_ERROR;
         }
-        // Keep the phase across subsequent reads, then immediately try the
-        // ACK path below in case Hello and ACK arrived in one TCP packet.
-        socket->reset_parsing_context(ServerHandshakeContext::Create());
-    }
+        // This server cannot upgrade, so any well-framed ACK completes the
+        // downgrade. A conforming peer sends zero after the disabled hello.
+        *enabled = false;
+        return handshake::STEP_OK;
+    };
+    return codec;
+}
 
-    // Phase 2: drain the 4B ACK.
-    if (source->size() < HELLO_ACK_LEN) {
+static ParseResult FallbackServerHandshake(
+    butil::IOBuf* source, Socket* socket) {
+    AdapterTransport* adapter = AdapterTransport::Get(socket);
+    handshake::IOBufHandshakeInput input(source);
+    handshake::ServerHandshakeCallbacks callbacks{};
+    callbacks.phases = handshake::HandshakePhases{1, 2, 3, 4, 5, 6};
+    callbacks.fallback_on_not_mine = false;
+    callbacks.codecs.push_back(MakeFallbackCodec(2));
+    callbacks.codecs.push_back(MakeFallbackCodec(3));
+    callbacks.input = &input;
+    callbacks.prepare_resources = []() { return handshake::STEP_OK; };
+    callbacks.negotiate_resources = []() { return handshake::STEP_OK; };
+    callbacks.set_high_speed_active = []() {};
+    callbacks.set_tcp_active = []() {};
+    callbacks.on_failed = []() {};
+
+    const handshake::StepResult result =
+        adapter->handshake_session()->RunServer(callbacks);
+    if (result == handshake::STEP_NEED_MORE) {
+        if (adapter->handshake_phase() == callbacks.phases.ack_wait &&
+            socket->parsing_context() == NULL) {
+            socket->reset_parsing_context(ServerHandshakeContext::Create());
+        }
         return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
     }
-    CHECK_EQ(source->pop_front(HELLO_ACK_LEN), HELLO_ACK_LEN);
-    // Handshake done (downgraded to TCP); drop the context and let
-    // InputMessenger parse the following real RPC.
     socket->reset_parsing_context(NULL);
+    if (result == handshake::STEP_ERROR) {
+        return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
+    }
     return MakeParseError(PARSE_ERROR_TRY_OTHERS);
 }
 
 ParseResult ExecuteServerHandshake(butil::IOBuf* source, Socket* socket) {
-    // Only RDMA-mode connections carry a live RdmaEndpoint and run the real
-    // handshake. A connection that is not in RDMA mode (RDMA compiled in but
-    // this connection is plain TCP, or RDMA not compiled at all) falls back.
 #if BRPC_WITH_RDMA
     if (socket->socket_mode() == SOCKET_MODE_RDMA) {
         return RdmaTransport::ExecuteServerHandshake(source, socket);
diff --git a/src/brpc/rdma_transport.cpp b/src/brpc/rdma_transport.cpp
index f651993a26..98e912113e 100644
--- a/src/brpc/rdma_transport.cpp
+++ b/src/brpc/rdma_transport.cpp
@@ -18,7 +18,6 @@
 #if BRPC_WITH_RDMA
 
 #include "brpc/rdma_transport.h"
-#include "butil/sys_byteorder.h"
 #include "brpc/adapter_transport.h"
 #include "brpc/event_dispatcher.h"
 #include "brpc/input_messenger.h"
@@ -113,18 +112,16 @@ void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
         << "Start handshake on " << socket->description();
 
     std::unique_ptr<rdma::RdmaHandshakeAdapter> protocol =
-        rdma::CreateClientHandshakeAdapter(
-            ep, transport->handshake_session()->io());
+        rdma::CreateClientHandshakeAdapter(ep);
     CHECK(protocol != NULL);
-    transport->handshake_session()->set_protocol_version(
-        protocol->ProtocolVersion());
     rdma::ParsedHello remote{};
 
     handshake::ClientHandshakeCallbacks callbacks{};
     callbacks.phases = handshake::HandshakePhases{
         C_ALLOC_QPCQ, C_HELLO_SEND, C_HELLO_WAIT,
         C_BRINGUP_QP, C_ACK_SEND, 0};
-    callbacks.prepare_local = [&]() {
+    callbacks.codec = protocol->MakeCodec(&remote);
+    callbacks.prepare_resources = [&]() {
         if (ep->AllocateResources() == 0) {
             return handshake::STEP_OK;
         }
@@ -135,31 +132,6 @@ void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
         errno = 0;
         return handshake::STEP_FALLBACK;
     };
-    callbacks.send_local_hello = [&]() {
-        if (protocol->SendLocalHello(true) == 0) {
-            return handshake::STEP_OK;
-        }
-        const int saved_errno = errno;
-        socket->SetFailed(saved_errno,
-                          "Fail to complete rdma handshake from %s: %s",
-                          socket->description().c_str(), berror(saved_errno));
-        return handshake::STEP_ERROR;
-    };
-    callbacks.receive_remote_hello = [&]() {
-        const rdma::RemoteHelloResult result =
-            protocol->ReceiveAndParseRemoteHello(&remote);
-        if (result == rdma::RemoteHelloResult::NEGOTIATED) {
-            return handshake::STEP_OK;
-        }
-        if (result != rdma::RemoteHelloResult::ERROR) {
-            return handshake::STEP_FALLBACK;
-        }
-        const int saved_errno = errno;
-        socket->SetFailed(saved_errno,
-                          "Fail to complete rdma handshake from %s: %s",
-                          socket->description().c_str(), berror(saved_errno));
-        return handshake::STEP_ERROR;
-    };
     callbacks.negotiate_resources = [&]() {
         ep->ApplyRemoteInfo(remote);
         if (ep->BringUpQp(remote, false) == 0) {
@@ -169,26 +141,18 @@ void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
                      << socket->description();
         return handshake::STEP_FALLBACK;
     };
-    callbacks.send_ack = [&](bool enabled) {
-        const uint32_t flags_be = butil::HostToNet32(
-            enabled ? rdma::HELLO_ACK_RDMA_OK : 0);
-        if (transport->handshake_session()->io()->WriteAll(
-                &flags_be, rdma::HELLO_ACK_LEN) == 0) {
-            return handshake::STEP_OK;
-        }
-        const int saved_errno = errno;
-        socket->SetFailed(saved_errno,
-                          "Fail to complete rdma handshake from %s: %s",
-                          socket->description().c_str(), berror(saved_errno));
-        return handshake::STEP_ERROR;
-    };
     callbacks.set_high_speed_active = [transport]() {
         transport->SetHighSpeedAvailable(true);
     };
     callbacks.set_tcp_active = [transport]() {
         transport->SetHighSpeedAvailable(false);
     };
-    callbacks.on_failed = []() {};
+    callbacks.on_failed = [&]() {
+        const int saved_errno = errno != 0 ? errno : EPROTO;
+        socket->SetFailed(saved_errno,
+                          "Fail to complete rdma handshake from %s: %s",
+                          socket->description().c_str(), berror(saved_errno));
+    };
 
     const handshake::StepResult result =
         transport->handshake_session()->RunClient(callbacks);
@@ -211,41 +175,31 @@ ParseResult RdmaTransport::ExecuteServerHandshake(butil::IOBuf* source,
     rdma::RdmaEndpoint* ep = transport->_rdma_ep;
     CHECK(ep != NULL);
 
-    std::unique_ptr<rdma::RdmaHandshakeAdapter> protocol;
     rdma::ParsedHello remote{};
+    std::vector<std::unique_ptr<rdma::RdmaHandshakeAdapter> > protocols =
+        rdma::CreateServerHandshakeAdapters(ep);
+    handshake::IOBufHandshakeInput input(source);
     handshake::ServerHandshakeCallbacks callbacks{};
     callbacks.phases = handshake::HandshakePhases{
         S_ALLOC_QPCQ, S_HELLO_SEND, S_HELLO_WAIT,
         S_BRINGUP_QP, 0, S_ACK_WAIT};
     callbacks.fallback_on_not_mine = false;
-    callbacks.receive_remote_hello = [&]() {
-        if (source->size() < rdma::HELLO_MAGIC_LEN) {
-            return handshake::STEP_NEED_MORE;
-        }
-        uint8_t magic[rdma::HELLO_MAGIC_LEN];
-        CHECK_EQ(source->copy_to(magic, sizeof(magic)), sizeof(magic));
-        protocol = rdma::CreateServerHandshakeAdapterByMagic(
-            ep, transport->handshake_session()->io(), source, magic);
-        if (protocol == NULL) {
-            return handshake::STEP_NOT_MINE;
-        }
-        transport->handshake_session()->set_protocol_version(
-            protocol->ProtocolVersion());
-        const rdma::RemoteHelloResult result =
-            protocol->ReceiveAndParseRemoteHello(&remote);
-        if (result == rdma::RemoteHelloResult::NEED_MORE) {
-            return handshake::STEP_NEED_MORE;
-        }
-        if (result == rdma::RemoteHelloResult::ERROR) {
-            return handshake::STEP_ERROR;
-        }
-        if (result == rdma::RemoteHelloResult::NEGOTIATED) {
-            return handshake::STEP_OK;
-        }
-        transport->_rdma_state = RDMA_OFF;
-        return handshake::STEP_FALLBACK;
-    };
-    callbacks.prepare_local = [&]() {
+    callbacks.input = &input;
+    for (size_t i = 0; i < protocols.size(); ++i) {
+        handshake::HandshakeCodec codec = protocols[i]->MakeCodec(&remote);
+        const std::function<handshake::StepResult(const std::string&)>
+            parse_hello = codec.parse_hello;
+        codec.parse_hello = [transport, parse_hello](
+            const std::string& payload) {
+            const handshake::StepResult result = parse_hello(payload);
+            if (result == handshake::STEP_FALLBACK) {
+                transport->_rdma_state = RDMA_OFF;
+            }
+            return result;
+        };
+        callbacks.codecs.push_back(codec);
+    }
+    callbacks.prepare_resources = [&]() {
         ep->ApplyRemoteInfo(remote);
         if (ep->AllocateResources() < 0) {
             PLOG(WARNING) << "Fail to allocate rdma resources, fallback to tcp:"
@@ -262,24 +216,7 @@ ParseResult RdmaTransport::ExecuteServerHandshake(butil::IOBuf* source,
         }
         return handshake::STEP_OK;
     };
-    callbacks.send_local_hello = [&](bool enabled) {
-        CHECK(protocol != NULL);
-        return protocol->SendLocalHello(enabled) == 0
-            ? handshake::STEP_OK : handshake::STEP_ERROR;
-    };
-    callbacks.receive_ack = [&]() {
-        if (source->size() < rdma::HELLO_ACK_LEN) {
-            return handshake::STEP_NEED_MORE;
-        }
-        uint32_t flags_be = 0;
-        CHECK_EQ(source->cutn(&flags_be, rdma::HELLO_ACK_LEN),
-                 rdma::HELLO_ACK_LEN);
-        const bool client_ack_ok =
-            (butil::NetToHost32(flags_be) & rdma::HELLO_ACK_RDMA_OK) != 0;
-        if (!client_ack_ok) {
-            // Keep coalesced RPC bytes for InputMessenger after fallback.
-            return handshake::STEP_FALLBACK;
-        }
+    callbacks.validate_established = [&]() {
         if (!source->empty() || transport->_rdma_state == RDMA_OFF) {
             return handshake::STEP_ERROR;
         }
diff --git a/src/brpc/socket.h b/src/brpc/socket.h
index 70904d98d4..b5e8a76787 100644
--- a/src/brpc/socket.h
+++ b/src/brpc/socket.h
@@ -61,6 +61,9 @@ namespace ubring {
     class UBShmEndpoint;
     class UBConnect;
 }
+namespace handshake {
+class SocketHandshakeIO;
+}
 class Socket;
 class AuthContext;
 class EventDispatcher;
@@ -336,6 +339,7 @@ friend class IOEvent<Socket>;
 friend void DereferenceSocket(Socket*);
 friend class Transport;
 friend class AdapterTransport;
+friend class handshake::SocketHandshakeIO;
 friend class TcpTransport;
 friend class RdmaTransport;
 friend class TransportFactory;
diff --git a/src/brpc/transport_handshake.cpp b/src/brpc/transport_handshake.cpp
index e8dca5aacf..aece41c83c 100644
--- a/src/brpc/transport_handshake.cpp
+++ b/src/brpc/transport_handshake.cpp
@@ -17,16 +17,10 @@
 
 #include "brpc/transport_handshake.h"
 
-#include <cstdint>
 #include <errno.h>
-#include <unistd.h>
 
-#include "bthread/butex.h"
-#include "butil/time.h"
 #include "butil/logging.h"
 #include "butil/object_pool.h"
-#include "brpc/errno.pb.h"
-#include "brpc/socket.h"
 
 namespace brpc {
 namespace handshake {
@@ -39,148 +33,143 @@ void ServerHandshakeContext::Destroy() {
     butil::return_object(this);
 }
 
-static const int WAIT_TIMEOUT_MS = 50;
-
-SocketHandshakeIO::SocketHandshakeIO(Socket* socket)
-    : _socket(socket)
-    , _read_butex(bthread::butex_create_checked<butil::atomic<int> >()) {
-}
-
-SocketHandshakeIO::~SocketHandshakeIO() {
-    bthread::butex_destroy(_read_butex);
-}
-
-void SocketHandshakeIO::Reset(Socket* socket) {
-    _socket = socket;
-}
-
-void SocketHandshakeIO::NotifyReadable() {
-    _read_butex->fetch_add(1, butil::memory_order_release);
-    bthread::butex_wake(_read_butex);
+static StepResult FinishWithFailure(
+    HandshakeSession* session, const std::function<void()>& on_failed) {
+    if (on_failed) {
+        on_failed();
+    }
+    session->MarkFailed();
+    return STEP_ERROR;
 }
 
-template <typename ReadOnce>
-static int ReadExactLoop(butil::atomic<int>* read_butex,
-                         size_t len, ReadOnce read_once) {
-    size_t received = 0;
-    while (received < len) {
-        const int expected = read_butex->load(butil::memory_order_acquire);
-        const timespec duetime = butil::milliseconds_from_now(WAIT_TIMEOUT_MS);
-        const ssize_t nr = read_once(received, len - received);
-        if (nr < 0) {
-            if (errno != EAGAIN) {
-                return -1;
-            }
-            if (bthread::butex_wait(read_butex, expected, &duetime) < 0 &&
-                errno != EWOULDBLOCK && errno != ETIMEDOUT) {
-                return -1;
-            }
-        } else if (nr == 0) {
-            errno = EEOF;
-            return -1;
-        } else {
-            received += nr;
+static StepResult FinishWithFallback(
+    HandshakeSession* session, const std::function<void()>& set_tcp_active) {
+    session->PublishFallback([&set_tcp_active]() {
+        if (set_tcp_active) {
+            set_tcp_active();
         }
-    }
-    return 0;
+    });
+    return STEP_FALLBACK;
 }
 
-int SocketHandshakeIO::ReadExact(void* data, size_t len) {
-    CHECK(data != NULL);
-    CHECK(_socket != NULL);
-    const int fd = _socket->fd();
-    return ReadExactLoop(_read_butex, len,
-        [data, fd](size_t offset, size_t remaining) {
-            return read(fd, static_cast<uint8_t*>(data) + offset, remaining);
-        });
+static StepResult ConvertFrameResult(FrameResult result) {
+    switch (result) {
+    case FRAME_OK: return STEP_OK;
+    case FRAME_NOT_MINE: return STEP_NOT_MINE;
+    case FRAME_NEED_MORE: return STEP_NEED_MORE;
+    case FRAME_IO_ERROR: return STEP_ERROR;
+    case FRAME_PROTOCOL_ERROR:
+        errno = EPROTO;
+        return STEP_ERROR;
+    }
+    errno = EPROTO;
+    return STEP_ERROR;
 }
 
-int SocketHandshakeIO::ReadExact(butil::IOPortal* data, size_t len) {
-    CHECK(data != NULL);
-    CHECK(_socket != NULL);
-    const int fd = _socket->fd();
-    return ReadExactLoop(_read_butex, len,
-        [data, fd](size_t, size_t remaining) {
-            return data->append_from_file_descriptor(fd, remaining);
-        });
+StepResult HandshakeSession::SendHello(const HandshakeCodec& codec,
+                                       bool enabled) {
+    CHECK(codec.build_hello);
+    std::string payload;
+    const StepResult result = codec.build_hello(enabled, &payload);
+    if (result != STEP_OK) {
+        return result;
+    }
+    return ConvertFrameResult(
+        FrameCodec::WriteFrame(_io, codec.hello_frame, payload));
 }
 
-template <typename WriteOnce>
-static int WriteAllLoop(Socket* socket, size_t len, WriteOnce write_once) {
-    size_t written = 0;
-    while (written < len) {
-        const timespec duetime = butil::milliseconds_from_now(WAIT_TIMEOUT_MS);
-        const ssize_t nw = write_once(written, len - written);
-        if (nw > 0) {
-            written += nw;
-            continue;
-        }
-        if (nw == 0) {
-            errno = EPIPE;
-            return -1;
-        }
-        if (errno != EAGAIN) {
-            return -1;
-        }
-        if (socket->WaitEpollOut(socket->fd(), true, &duetime) < 0 &&
-            errno != ETIMEDOUT) {
-            return -1;
-        }
+StepResult HandshakeSession::ReceiveHello(const HandshakeCodec& codec,
+                                          HandshakeInput* input,
+                                          bool push_back_on_not_mine,
+                                          bool* magic_matched) {
+    CHECK(codec.parse_hello);
+    std::string payload;
+    const FrameResult frame_result = input != NULL
+        ? FrameCodec::ParseBufferedFrame(
+              input, codec.hello_frame, &payload, magic_matched)
+        : FrameCodec::ReadFrame(
+              _io, codec.hello_frame, push_back_on_not_mine, &payload);
+    const StepResult result = ConvertFrameResult(frame_result);
+    if (result != STEP_OK) {
+        return result;
     }
-    return 0;
+    set_protocol_version(codec.protocol_version);
+    return codec.parse_hello(payload);
 }
 
-int SocketHandshakeIO::WriteAll(const void* data, size_t len) {
-    CHECK(data != NULL);
-    CHECK(_socket != NULL);
-    const int fd = _socket->fd();
-    return WriteAllLoop(_socket, len,
-        [data, fd](size_t offset, size_t remaining) {
-            return write(fd, static_cast<const uint8_t*>(data) + offset, remaining);
-        });
+StepResult HandshakeSession::SendAck(const HandshakeCodec& codec,
+                                     bool enabled) {
+    CHECK(codec.build_ack);
+    std::string payload;
+    const StepResult result = codec.build_ack(enabled, &payload);
+    if (result != STEP_OK) {
+        return result;
+    }
+    return ConvertFrameResult(
+        FrameCodec::WriteFrame(_io, codec.ack_frame, payload));
 }
 
-int SocketHandshakeIO::WriteAll(butil::IOBuf* data) {
-    CHECK(data != NULL);
-    CHECK(_socket != NULL);
-    const int fd = _socket->fd();
-    return WriteAllLoop(_socket, data->size(),
-        [data, fd](size_t, size_t) {
-            return data->cut_into_file_descriptor(fd);
-        });
+StepResult HandshakeSession::ReceiveAck(const HandshakeCodec& codec,
+                                        HandshakeInput* input,
+                                        bool* enabled) {
+    CHECK(codec.parse_ack);
+    std::string payload;
+    const FrameResult frame_result = input != NULL
+        ? FrameCodec::ParseBufferedFrame(input, codec.ack_frame, &payload)
+        : FrameCodec::ReadFrame(_io, codec.ack_frame, false, &payload);
+    const StepResult result = ConvertFrameResult(frame_result);
+    if (result != STEP_OK) {
+        return result;
+    }
+    return codec.parse_ack(payload, enabled);
 }
 
-static StepResult FinishWithFailure(
-    HandshakeSession* session, const std::function<void()>& on_failed) {
-    if (on_failed) {
-        on_failed();
+StepResult HandshakeSession::SelectAndReceiveHello(
+    const std::vector<HandshakeCodec>& codecs, HandshakeInput* input,
+    bool push_back_on_not_mine, const HandshakeCodec** selected) {
+    CHECK(!codecs.empty());
+    CHECK(selected != NULL);
+    if (input == NULL) {
+        // A blocking byte stream cannot try a second codec after consuming
+        // bytes from the fd. Such protocols must select a single codec before
+        // entering the common session.
+        CHECK_EQ(1UL, codecs.size());
+        *selected = &codecs.front();
+        return ReceiveHello(**selected, NULL, push_back_on_not_mine);
     }
-    session->MarkFailed();
-    return STEP_ERROR;
-}
 
-static StepResult FinishWithFallback(
-    HandshakeSession* session, const std::function<void()>& set_tcp_active) {
-    session->PublishFallback([&set_tcp_active]() {
-        if (set_tcp_active) {
-            set_tcp_active();
+    bool need_more = false;
+    for (size_t i = 0; i < codecs.size(); ++i) {
+        bool magic_matched = false;
+        const StepResult result = ReceiveHello(
+            codecs[i], input, false, &magic_matched);
+        if (result == STEP_NOT_MINE) {
+            continue;
         }
-    });
-    return STEP_FALLBACK;
+        if (result == STEP_NEED_MORE) {
+            if (magic_matched) {
+                *selected = &codecs[i];
+                set_protocol_version(codecs[i].protocol_version);
+                return STEP_NEED_MORE;
+            }
+            need_more = true;
+            continue;
+        }
+        *selected = &codecs[i];
+        return result;
+    }
+    return need_more ? STEP_NEED_MORE : STEP_NOT_MINE;
 }
 
 StepResult HandshakeSession::RunClient(
     const ClientHandshakeCallbacks& callbacks) {
-    CHECK(callbacks.prepare_local);
-    CHECK(callbacks.send_local_hello);
-    CHECK(callbacks.receive_remote_hello);
+    CHECK(callbacks.prepare_resources);
     CHECK(callbacks.negotiate_resources);
-    CHECK(callbacks.send_ack);
     CHECK(callbacks.set_high_speed_active);
     CHECK(callbacks.set_tcp_active);
 
     SetPhase(callbacks.phases.prepare_local);
-    StepResult result = callbacks.prepare_local();
+    StepResult result = callbacks.prepare_resources();
     if (result == STEP_FALLBACK) {
         return FinishWithFallback(this, callbacks.set_tcp_active);
     }
@@ -189,12 +178,12 @@ StepResult HandshakeSession::RunClient(
     }
 
     SetPhase(callbacks.phases.hello_send);
-    if (callbacks.send_local_hello() != STEP_OK) {
+    if (SendHello(callbacks.codec, true) != STEP_OK) {
         return FinishWithFailure(this, callbacks.on_failed);
     }
 
     SetPhase(callbacks.phases.hello_wait);
-    result = callbacks.receive_remote_hello();
+    result = ReceiveHello(callbacks.codec, NULL, false);
     if (result == STEP_ERROR || result == STEP_NOT_MINE ||
         result == STEP_NEED_MORE) {
         return FinishWithFailure(this, callbacks.on_failed);
@@ -211,7 +200,7 @@ StepResult HandshakeSession::RunClient(
     }
 
     SetPhase(callbacks.phases.ack_send);
-    if (callbacks.send_ack(enabled) != STEP_OK) {
+    if (SendAck(callbacks.codec, enabled) != STEP_OK) {
         return FinishWithFailure(this, callbacks.on_failed);
     }
 
@@ -225,17 +214,27 @@ StepResult HandshakeSession::RunClient(
 
 StepResult HandshakeSession::RunServer(
     const ServerHandshakeCallbacks& callbacks) {
-    CHECK(callbacks.receive_remote_hello);
-    CHECK(callbacks.prepare_local);
+    CHECK(!callbacks.codecs.empty());
+    CHECK(callbacks.prepare_resources);
     CHECK(callbacks.negotiate_resources);
-    CHECK(callbacks.send_local_hello);
-    CHECK(callbacks.receive_ack);
     CHECK(callbacks.set_high_speed_active);
     CHECK(callbacks.set_tcp_active);
 
+    // Once TCP fallback has been published, subsequent bytes are application
+    // protocol data and must bypass every upgrade codec without changing the
+    // terminal state.
+    if (phase() == FALLBACK_TCP) {
+        return STEP_NOT_MINE;
+    }
+
+    const HandshakeCodec* selected = NULL;
     if (phase() != callbacks.phases.ack_wait) {
+        const int previous_phase = phase();
+        _local_enabled = false;
         SetPhase(callbacks.phases.hello_wait);
-        StepResult result = callbacks.receive_remote_hello();
+        StepResult result = SelectAndReceiveHello(
+            callbacks.codecs, callbacks.input,
+            callbacks.fallback_on_not_mine, &selected);
         if (result == STEP_NOT_MINE) {
             if (callbacks.fallback_on_not_mine) {
                 return FinishWithFallback(this, callbacks.set_tcp_active);
@@ -244,6 +243,9 @@ StepResult HandshakeSession::RunServer(
             return STEP_NOT_MINE;
         }
         if (result == STEP_NEED_MORE) {
+            if (selected == NULL) {
+                SetPhase(previous_phase);
+            }
             return STEP_NEED_MORE;
         }
         if (result == STEP_ERROR) {
@@ -253,7 +255,7 @@ StepResult HandshakeSession::RunServer(
 
         if (enabled) {
             SetPhase(callbacks.phases.prepare_local);
-            result = callbacks.prepare_local();
+            result = callbacks.prepare_resources();
             if (result != STEP_OK && result != STEP_FALLBACK) {
                 return FinishWithFailure(this, callbacks.on_failed);
             }
@@ -270,17 +272,29 @@ StepResult HandshakeSession::RunServer(
         }
 
         SetPhase(callbacks.phases.hello_send);
-        if (callbacks.send_local_hello(enabled) != STEP_OK) {
+        CHECK(selected != NULL);
+        _local_enabled = enabled;
+        if (SendHello(*selected, enabled) != STEP_OK) {
             return FinishWithFailure(this, callbacks.on_failed);
         }
         SetPhase(callbacks.phases.ack_wait);
+    } else {
+        for (size_t i = 0; i < callbacks.codecs.size(); ++i) {
+            if (callbacks.codecs[i].protocol_version == protocol_version()) {
+                selected = &callbacks.codecs[i];
+                break;
+            }
+        }
+        CHECK(selected != NULL);
     }
 
     // Always try the ACK callback once. For a non-blocking server it returns
     // STEP_NEED_MORE when the ACK has not arrived; when Hello and ACK are
     // coalesced in the input buffer this consumes the ACK without waiting for
     // another socket edge.
-    StepResult result = callbacks.receive_ack();
+    bool peer_enabled = false;
+    StepResult result = ReceiveAck(
+        *selected, callbacks.input, &peer_enabled);
     if (result == STEP_NEED_MORE) {
         return STEP_NEED_MORE;
     }
@@ -290,6 +304,17 @@ StepResult HandshakeSession::RunServer(
     if (result == STEP_FALLBACK) {
         return FinishWithFallback(this, callbacks.set_tcp_active);
     }
+    if (!peer_enabled) {
+        return FinishWithFallback(this, callbacks.set_tcp_active);
+    }
+    if (!_local_enabled) {
+        errno = EPROTO;
+        return FinishWithFailure(this, callbacks.on_failed);
+    }
+    if (callbacks.validate_established &&
+        callbacks.validate_established() != STEP_OK) {
+        return FinishWithFailure(this, callbacks.on_failed);
+    }
 
     callbacks.set_high_speed_active();
     MarkEstablished();
diff --git a/src/brpc/transport_handshake.h b/src/brpc/transport_handshake.h
index b2d0b643a2..7ac4422395 100644
--- a/src/brpc/transport_handshake.h
+++ b/src/brpc/transport_handshake.h
@@ -20,11 +20,13 @@
 
 #include <cstddef>
 #include <functional>
+#include <string>
+#include <vector>
 
 #include "butil/atomicops.h"
-#include "butil/iobuf.h"
 #include "butil/macros.h"
 #include "brpc/destroyable.h"
+#include "brpc/handshake/handshake_frame.h"
 
 namespace brpc {
 
@@ -67,15 +69,26 @@ struct HandshakePhases {
     int ack_wait;
 };
 
-// Protocol-specific operations invoked by the common client driver. A
-// callback reports what happened but does not advance the session phase.
+// A protocol describes only its fields and resource-independent wire values.
+// HandshakeSession owns framing and I/O through FrameCodec. The callbacks may
+// retain strongly typed parsed state in their protocol adapter.
+struct HandshakeCodec {
+    int protocol_version;
+    FrameSpec hello_frame;
+    FrameSpec ack_frame;
+    std::function<StepResult(bool, std::string*)> build_hello;
+    std::function<StepResult(const std::string&)> parse_hello;
+    std::function<StepResult(bool, std::string*)> build_ack;
+    std::function<StepResult(const std::string&, bool*)> parse_ack;
+};
+
+// Resource-specific operations invoked by the common client driver. Wire I/O
+// and field codec invocation are owned by HandshakeSession.
 struct ClientHandshakeCallbacks {
     HandshakePhases phases;
-    std::function<StepResult()> prepare_local;
-    std::function<StepResult()> send_local_hello;
-    std::function<StepResult()> receive_remote_hello;
+    HandshakeCodec codec;
+    std::function<StepResult()> prepare_resources;
     std::function<StepResult()> negotiate_resources;
-    std::function<StepResult(bool)> send_ack;
     std::function<void()> set_high_speed_active;
     std::function<void()> set_tcp_active;
     std::function<void()> on_failed;
@@ -86,52 +99,32 @@ struct ClientHandshakeCallbacks {
 struct ServerHandshakeCallbacks {
     HandshakePhases phases;
     bool fallback_on_not_mine;
-    std::function<StepResult()> receive_remote_hello;
-    std::function<StepResult()> prepare_local;
+    // Buffered parsers may offer multiple codecs (RDMA v2/v3). Blocking
+    // server handshakes currently provide exactly one codec.
+    std::vector<HandshakeCodec> codecs;
+    HandshakeInput* input;
+    std::function<StepResult()> prepare_resources;
     std::function<StepResult()> negotiate_resources;
-    std::function<StepResult(bool)> send_local_hello;
-    std::function<StepResult()> receive_ack;
+    std::function<StepResult()> validate_established;
     std::function<void()> set_high_speed_active;
     std::function<void()> set_tcp_active;
     std::function<void()> on_failed;
 };
 
-// Owns TCP-fd I/O and its readable notification while upgrading a connection.
-// The handshake lifecycle is owned by HandshakeSession below.
-class SocketHandshakeIO {
-public:
-    explicit SocketHandshakeIO(Socket* socket = NULL);
-    ~SocketHandshakeIO();
-
-    void Reset(Socket* socket);
-
-    void NotifyReadable();
-
-    // Read/write exactly len bytes. EAGAIN is handled by waiting for the
-    // socket event callback; EOF is reported as EEOF.
-    int ReadExact(void* data, size_t len);
-    int ReadExact(butil::IOPortal* data, size_t len);
-    int WriteAll(const void* data, size_t len);
-    int WriteAll(butil::IOBuf* data);
-
-private:
-    Socket* _socket;
-    butil::atomic<int>* _read_butex;
-
-    DISALLOW_COPY_AND_ASSIGN(SocketHandshakeIO);
-};
-
-// Owns one connection-upgrade attempt. Wire codecs and endpoint resource
-// operations remain protocol adapters, while this class provides the common
-// lifecycle, publication ordering and TCP control-plane I/O.
+// Owns one connection-upgrade attempt, invokes the protocol field codec and
+// resource callbacks, and provides common framing, TCP control-plane I/O,
+// lifecycle and publication ordering.
 class HandshakeSession {
 public:
     explicit HandshakeSession(Socket* socket = NULL)
-        : _io(socket), _phase(UNINITIALIZED), _protocol_version(0) {}
+        : _socket_io(socket), _io(&_socket_io), _phase(UNINITIALIZED),
+          _protocol_version(0), _local_enabled(false) {}
 
     void Reset(Socket* socket) {
-        _io.Reset(socket);
+        _socket_io.Reset(socket);
+        _io = &_socket_io;
         _protocol_version = 0;
+        _local_enabled = false;
         _phase.store(UNINITIALIZED, butil::memory_order_relaxed);
     }
 
@@ -164,17 +157,33 @@ class HandshakeSession {
         _phase.store(FALLBACK_TCP, butil::memory_order_release);
     }
 
-    SocketHandshakeIO* io() { return &_io; }
-    const SocketHandshakeIO* io() const { return &_io; }
-    void NotifyReadable() { _io.NotifyReadable(); }
+    void NotifyReadable() { _socket_io.NotifyReadable(); }
+
+    // Injects an in-memory stream in common-component unit tests. Reset()
+    // restores the Socket-backed implementation.
+    void SetIOForTest(HandshakeIO* io) { _io = io; }
 
     StepResult RunClient(const ClientHandshakeCallbacks& callbacks);
     StepResult RunServer(const ServerHandshakeCallbacks& callbacks);
 
 private:
-    SocketHandshakeIO _io;
+    StepResult SendHello(const HandshakeCodec& codec, bool enabled);
+    StepResult ReceiveHello(const HandshakeCodec& codec,
+                            HandshakeInput* input,
+                            bool push_back_on_not_mine,
+                            bool* magic_matched = NULL);
+    StepResult SendAck(const HandshakeCodec& codec, bool enabled);
+    StepResult ReceiveAck(const HandshakeCodec& codec,
+                          HandshakeInput* input, bool* enabled);
+    StepResult SelectAndReceiveHello(
+        const std::vector<HandshakeCodec>& codecs, HandshakeInput* input,
+        bool push_back_on_not_mine, const HandshakeCodec** selected);
+
+    SocketHandshakeIO _socket_io;
+    HandshakeIO* _io;
     butil::atomic<int> _phase;
     int _protocol_version;
+    bool _local_enabled;
 
     DISALLOW_COPY_AND_ASSIGN(HandshakeSession);
 };
diff --git a/src/brpc/ubshm/ub_endpoint.cpp b/src/brpc/ubshm/ub_endpoint.cpp
index 4c194d7d18..d671fb61af 100644
--- a/src/brpc/ubshm/ub_endpoint.cpp
+++ b/src/brpc/ubshm/ub_endpoint.cpp
@@ -85,8 +85,8 @@ void HelloMessage::Serialize(void* data) const {
     memcpy(current_pos, shm_name, SHM_MAX_NAME_BUFF_LEN);
 }
 
-void HelloMessage::Deserialize(void* data) {
-    char* current_pos = static_cast<char*>(data);
+void HelloMessage::Deserialize(const void* data) {
+    const char* current_pos = static_cast<const char*>(data);
     uint16_t net_msg_len;
     memcpy(&net_msg_len, current_pos, sizeof(net_msg_len));
     msg_len = butil::NetToHost16(net_msg_len);
@@ -209,6 +209,34 @@ bool HelloNegotiationValid(HelloMessage& msg) {
     return false;
 }
 
+static handshake::HandshakeCodec MakeUBHandshakeCodec() {
+    handshake::HandshakeCodec codec{};
+    codec.protocol_version = 2;
+    codec.hello_frame = handshake::FrameSpec(
+        MAGIC_STR, MAGIC_STR_LEN, HELLO_MSG_LEN_MIN, HELLO_MSG_LEN_MIN,
+        handshake::FrameSpec::FIXED);
+    codec.ack_frame = handshake::FrameSpec(
+        NULL, 0, ACK_MSG_LEN, ACK_MSG_LEN, handshake::FrameSpec::FIXED);
+    codec.build_ack = [](bool enabled, std::string* payload) {
+        const uint32_t flags_be = butil::HostToNet32(
+            enabled ? ACK_MSG_UB_OK : 0);
+        payload->assign(reinterpret_cast<const char*>(&flags_be),
+                        sizeof(flags_be));
+        return handshake::STEP_OK;
+    };
+    codec.parse_ack = [](const std::string& payload, bool* enabled) {
+        if (payload.size() != ACK_MSG_LEN) {
+            errno = EPROTO;
+            return handshake::STEP_ERROR;
+        }
+        uint32_t flags_be = 0;
+        memcpy(&flags_be, payload.data(), sizeof(flags_be));
+        *enabled = (butil::NetToHost32(flags_be) & ACK_MSG_UB_OK) != 0;
+        return handshake::STEP_OK;
+    };
+    return codec;
+}
+
 void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
     UBShmTransport* ub_transport = static_cast<UBShmTransport*>(arg);
     UBShmEndpoint* ep = ub_transport->_ub_ep;
@@ -218,7 +246,6 @@ void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
     LOG_IF(INFO, FLAGS_ub_trace_verbose) 
         << "Start handshake on " << s->_local_side;
 
-    uint8_t data[g_ub_hello_msg_len];
     size_t local_shm_len = (size_t)(FLAGS_data_queue_size) * MB_TO_BYTE;
     SHM local_trx_shm = {NULL, local_shm_len, 0, {0}, (uint32_t)s->fd()};
     auto shm_name_str = butil::endpoint2str(s->local_side());
@@ -229,15 +256,9 @@ void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
     callbacks.phases = handshake::HandshakePhases{
         C_ALLOC_SHM, C_HELLO_SEND, C_HELLO_WAIT,
         C_MAP_REMOTE_SHM, C_ACK_SEND, 0};
-    callbacks.prepare_local = [&]() {
-        if (ep->AllocateClientResources(&local_trx_shm, shm_name) == 0) {
-            return handshake::STEP_OK;
-        }
-        LOG(WARNING) << "Fallback to tcp:" << s->description();
-        errno = 0;
-        return handshake::STEP_FALLBACK;
-    };
-    callbacks.send_local_hello = [&]() {
+    callbacks.codec = MakeUBHandshakeCodec();
+    callbacks.codec.build_hello = [&](bool enabled, std::string* payload) {
+        CHECK(enabled);
         HelloMessage local_msg{};
         local_msg.msg_len = g_ub_hello_msg_len;
         local_msg.hello_ver = g_ub_hello_version;
@@ -245,50 +266,20 @@ void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
         local_msg.len = local_shm_len;
         memcpy(local_msg.shm_name, local_trx_shm.name,
                SHM_MAX_NAME_BUFF_LEN);
-        memcpy(data, MAGIC_STR, MAGIC_STR_LEN);
-        local_msg.Serialize((char*)data + MAGIC_STR_LEN);
-        if (ub_transport->handshake_session()->io()->WriteAll(
-                data, g_ub_hello_msg_len) == 0) {
-            LOG_IF(INFO, FLAGS_ub_trace_verbose)
-                << "client handshake message : " << local_msg.toString();
-            return handshake::STEP_OK;
-        }
-        const int saved_errno = errno;
-        PLOG(WARNING) << "Fail to send hello message to server:"
-                      << s->description();
-        s->SetFailed(saved_errno,
-                     "Fail to complete ubring handshake from %s: %s",
-                     s->description().c_str(), berror(saved_errno));
-        return handshake::STEP_ERROR;
+        payload->assign(HELLO_MSG_LEN_MIN - MAGIC_STR_LEN, '\0');
+        local_msg.Serialize(&(*payload)[0]);
+        LOG_IF(INFO, FLAGS_ub_trace_verbose)
+            << "client handshake message : " << local_msg.toString();
+        return handshake::STEP_OK;
     };
-    callbacks.receive_remote_hello = [&]() {
-        if (ub_transport->handshake_session()->io()->ReadExact(
-                data, MAGIC_STR_LEN) < 0) {
-            const int saved_errno = errno;
-            s->SetFailed(saved_errno,
-                         "Fail to complete ubring handshake from %s: %s",
-                         s->description().c_str(), berror(saved_errno));
-            return handshake::STEP_ERROR;
-        }
-        if (memcmp(data, MAGIC_STR, MAGIC_STR_LEN) != 0) {
-            s->SetFailed(EPROTO,
-                         "Fail to complete ubring handshake from %s: %s",
-                         s->description().c_str(), berror(EPROTO));
-            return handshake::STEP_ERROR;
-        }
-        if (ub_transport->handshake_session()->io()->ReadExact(
-                data, HELLO_MSG_LEN_MIN - MAGIC_STR_LEN) < 0) {
-            const int saved_errno = errno;
-            s->SetFailed(saved_errno,
-                         "Fail to complete ubring handshake from %s: %s",
-                         s->description().c_str(), berror(saved_errno));
+    callbacks.codec.parse_hello = [&](const std::string& payload) {
+        if (payload.size() != HELLO_MSG_LEN_MIN - MAGIC_STR_LEN) {
+            errno = EPROTO;
             return handshake::STEP_ERROR;
         }
-        remote_msg.Deserialize(data);
+        remote_msg.Deserialize(payload.data());
         if (remote_msg.msg_len < HELLO_MSG_LEN_MIN) {
-            s->SetFailed(EPROTO,
-                         "Fail to complete ubring handshake from %s: %s",
-                         s->description().c_str(), berror(EPROTO));
+            errno = EPROTO;
             return handshake::STEP_ERROR;
         }
         if (!HelloNegotiationValid(remote_msg)) {
@@ -298,6 +289,14 @@ void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
         }
         return handshake::STEP_OK;
     };
+    callbacks.prepare_resources = [&]() {
+        if (ep->AllocateClientResources(&local_trx_shm, shm_name) == 0) {
+            return handshake::STEP_OK;
+        }
+        LOG(WARNING) << "Fallback to tcp:" << s->description();
+        errno = 0;
+        return handshake::STEP_FALLBACK;
+    };
     callbacks.negotiate_resources = [&]() {
         if (ep->_ub_ring->UbrMapRemoteShm(&local_trx_shm, shm_name) == 0) {
             return handshake::STEP_OK;
@@ -306,26 +305,18 @@ void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
                      << s->description();
         return handshake::STEP_FALLBACK;
     };
-    callbacks.send_ack = [&](bool enabled) {
-        uint32_t* flags = (uint32_t*)data;
-        *flags = butil::HostToNet32(enabled ? ACK_MSG_UB_OK : 0);
-        if (ub_transport->handshake_session()->io()->WriteAll(
-                data, ACK_MSG_LEN) == 0) {
-            return handshake::STEP_OK;
-        }
-        const int saved_errno = errno;
-        s->SetFailed(saved_errno,
-                     "Fail to complete ubring handshake from %s: %s",
-                     s->description().c_str(), berror(saved_errno));
-        return handshake::STEP_ERROR;
-    };
     callbacks.set_high_speed_active = [ub_transport]() {
         ub_transport->SetHighSpeedAvailable(true);
     };
     callbacks.set_tcp_active = [ub_transport]() {
         ub_transport->SetHighSpeedAvailable(false);
     };
-    callbacks.on_failed = []() {};
+    callbacks.on_failed = [&]() {
+        const int saved_errno = errno != 0 ? errno : EPROTO;
+        s->SetFailed(saved_errno,
+                     "Fail to complete ubring handshake from %s: %s",
+                     s->description().c_str(), berror(saved_errno));
+    };
 
     const handshake::StepResult result =
         ub_transport->handshake_session()->RunClient(callbacks);
@@ -351,43 +342,25 @@ void* UBShmTransport::ProcessHandshakeAtServer(void* arg) {
     LOG_IF(INFO, FLAGS_ub_trace_verbose)
         << "Start handshake on " << s->description();
 
-    uint8_t data[g_ub_hello_msg_len];
     HelloMessage remote_msg{};
-    bool local_enabled = false;
 
     handshake::ServerHandshakeCallbacks callbacks{};
     callbacks.phases = handshake::HandshakePhases{
         S_ALLOC_SHM, S_HELLO_SEND, S_HELLO_WAIT,
         S_ALLOC_SHM, 0, S_ACK_WAIT};
     callbacks.fallback_on_not_mine = true;
-    callbacks.receive_remote_hello = [&]() {
-        if (ub_transport->handshake_session()->io()->ReadExact(
-                data, MAGIC_STR_LEN) < 0) {
-            const int saved_errno = errno;
-            s->SetFailed(saved_errno,
-                         "Fail to complete ubring handshake from %s: %s",
-                         s->description().c_str(), berror(saved_errno));
-            return handshake::STEP_ERROR;
-        }
-        if (memcmp(data, MAGIC_STR, MAGIC_STR_LEN) != 0) {
-            s->_read_buf.append(data, MAGIC_STR_LEN);
-            return handshake::STEP_NOT_MINE;
-        }
-        if (ub_transport->handshake_session()->io()->ReadExact(
-                data, g_ub_hello_msg_len - MAGIC_STR_LEN) < 0) {
-            const int saved_errno = errno;
-            s->SetFailed(saved_errno,
-                         "Fail to complete ubring handshake from %s: %s",
-                         s->description().c_str(), berror(saved_errno));
+    callbacks.input = NULL;
+    handshake::HandshakeCodec codec = MakeUBHandshakeCodec();
+    codec.parse_hello = [&](const std::string& payload) {
+        if (payload.size() != HELLO_MSG_LEN_MIN - MAGIC_STR_LEN) {
+            errno = EPROTO;
             return handshake::STEP_ERROR;
         }
-        remote_msg.Deserialize(data);
+        remote_msg.Deserialize(payload.data());
         LOG_IF(INFO, FLAGS_ub_trace_verbose)
             << "server receive handshake message : " << remote_msg.toString();
         if (remote_msg.msg_len < HELLO_MSG_LEN_MIN) {
-            s->SetFailed(EPROTO,
-                         "Fail to complete ubring handshake from %s: %s",
-                         s->description().c_str(), berror(EPROTO));
+            errno = EPROTO;
             return handshake::STEP_ERROR;
         }
         if (!HelloNegotiationValid(remote_msg)) {
@@ -395,7 +368,22 @@ void* UBShmTransport::ProcessHandshakeAtServer(void* arg) {
         }
         return handshake::STEP_OK;
     };
-    callbacks.prepare_local = [&]() {
+    codec.build_hello = [&](bool enabled, std::string* payload) {
+        HelloMessage local_msg{};
+        local_msg.msg_len = g_ub_hello_msg_len;
+        if (enabled) {
+            local_msg.hello_ver = g_ub_hello_version;
+            local_msg.impl_ver = g_ub_impl_version;
+            local_msg.len = (FLAGS_data_queue_size) * MB_TO_BYTE;
+            memcpy(local_msg.shm_name, remote_msg.shm_name,
+                   SHM_MAX_NAME_BUFF_LEN);
+        }
+        payload->assign(HELLO_MSG_LEN_MIN - MAGIC_STR_LEN, '\0');
+        local_msg.Serialize(&(*payload)[0]);
+        return handshake::STEP_OK;
+    };
+    callbacks.codecs.push_back(codec);
+    callbacks.prepare_resources = [&]() {
         ubring::SHM remote_trx_shm = {
             NULL, remote_msg.len, 0, {0}, (uint32_t)ep->_socket->fd()};
         strncpy(remote_trx_shm.name, remote_msg.shm_name, SHM_MAX_NAME_BUFF_LEN);
@@ -428,50 +416,7 @@ void* UBShmTransport::ProcessHandshakeAtServer(void* arg) {
     callbacks.negotiate_resources = []() {
         return handshake::STEP_OK;
     };
-    callbacks.send_local_hello = [&](bool enabled) {
-        local_enabled = enabled;
-        HelloMessage local_msg{};
-        local_msg.msg_len = g_ub_hello_msg_len;
-        if (enabled) {
-            local_msg.hello_ver = g_ub_hello_version;
-            local_msg.impl_ver = g_ub_impl_version;
-            local_msg.len = (FLAGS_data_queue_size) * MB_TO_BYTE;
-            memcpy(local_msg.shm_name, remote_msg.shm_name,
-                   SHM_MAX_NAME_BUFF_LEN);
-        }
-        memcpy(data, MAGIC_STR, MAGIC_STR_LEN);
-        local_msg.Serialize((char*)data + MAGIC_STR_LEN);
-        if (ub_transport->handshake_session()->io()->WriteAll(
-                data, g_ub_hello_msg_len) == 0) {
-            return handshake::STEP_OK;
-        }
-        const int saved_errno = errno;
-        s->SetFailed(saved_errno,
-                     "Fail to complete ub handshake from %s: %s",
-                     s->description().c_str(), berror(saved_errno));
-        return handshake::STEP_ERROR;
-    };
-    callbacks.receive_ack = [&]() {
-        if (ub_transport->handshake_session()->io()->ReadExact(
-                data, ACK_MSG_LEN) < 0) {
-            const int saved_errno = errno;
-            s->SetFailed(saved_errno,
-                         "Fail to complete ubring handshake from %s: %s",
-                         s->description().c_str(), berror(saved_errno));
-            return handshake::STEP_ERROR;
-        }
-        uint32_t* flags = (uint32_t*)data;
-        const bool client_enabled =
-            (butil::NetToHost32(*flags) & ACK_MSG_UB_OK) != 0;
-        if (!client_enabled) {
-            return handshake::STEP_FALLBACK;
-        }
-        if (!local_enabled) {
-            s->SetFailed(EPROTO,
-                         "Fail to complete ub handshake from %s: %s",
-                         s->description().c_str(), berror(EPROTO));
-            return handshake::STEP_ERROR;
-        }
+    callbacks.validate_established = []() {
         return handshake::STEP_OK;
     };
     callbacks.set_high_speed_active = [ub_transport]() {
@@ -480,7 +425,12 @@ void* UBShmTransport::ProcessHandshakeAtServer(void* arg) {
     callbacks.set_tcp_active = [ub_transport]() {
         ub_transport->SetHighSpeedAvailable(false);
     };
-    callbacks.on_failed = []() {};
+    callbacks.on_failed = [&]() {
+        const int saved_errno = errno != 0 ? errno : EPROTO;
+        s->SetFailed(saved_errno,
+                     "Fail to complete ubring handshake from %s: %s",
+                     s->description().c_str(), berror(saved_errno));
+    };
 
     const handshake::StepResult result =
         ub_transport->handshake_session()->RunServer(callbacks);
diff --git a/src/brpc/ubshm/ub_endpoint.h b/src/brpc/ubshm/ub_endpoint.h
index 3baded0d94..794311972c 100644
--- a/src/brpc/ubshm/ub_endpoint.h
+++ b/src/brpc/ubshm/ub_endpoint.h
@@ -46,7 +46,7 @@ DECLARE_bool(ub_disable_bthread);
 
 struct HelloMessage {
     void Serialize(void* data) const;
-    void Deserialize(void* data);
+    void Deserialize(const void* data);
     std::string toString() const;
 
     uint16_t msg_len;
diff --git a/test/brpc_transport_handshake_unittest.cpp b/test/brpc_transport_handshake_unittest.cpp
index 8289314cb7..235a5d847d 100644
--- a/test/brpc_transport_handshake_unittest.cpp
+++ b/test/brpc_transport_handshake_unittest.cpp
@@ -17,159 +17,242 @@
 
 #include <gtest/gtest.h>
 
+#include <errno.h>
+#include <cstring>
 #include <string>
 
+#include "butil/sys_byteorder.h"
 #include "brpc/transport_handshake.h"
 
 namespace brpc {
 namespace handshake {
 
-TEST(TransportHandshakeTest, publish_fallback_after_tcp_state) {
-    HandshakeSession handshake;
-    int tcp_active = 0;
+class MemoryHandshakeIO : public HandshakeIO {
+public:
+    explicit MemoryHandshakeIO(const std::string& input = std::string())
+        : _input(input), _offset(0) {}
 
-    handshake.SetPhase(NEGOTIATING);
-    handshake.PublishFallback([&tcp_active]() { tcp_active = 1; });
+    int ReadExact(void* data, size_t len) override {
+        if (_input.size() - _offset < len) {
+            errno = EIO;
+            return -1;
+        }
+        memcpy(data, _input.data() + _offset, len);
+        _offset += len;
+        return 0;
+    }
 
-    ASSERT_EQ(1, tcp_active);
-    ASSERT_EQ(FALLBACK_TCP, handshake.phase());
+    int WriteAll(const void* data, size_t len) override {
+        _output.append(static_cast<const char*>(data), len);
+        return 0;
+    }
+
+    int PushBack(const void* data, size_t len) override {
+        _pushed_back.append(static_cast<const char*>(data), len);
+        return 0;
+    }
+
+    const std::string& output() const { return _output; }
+    const std::string& pushed_back() const { return _pushed_back; }
+
+private:
+    std::string _input;
+    size_t _offset;
+    std::string _output;
+    std::string _pushed_back;
+};
+
+static FrameSpec FixedSpec(const char* magic, size_t magic_len,
+                           size_t total_len) {
+    return FrameSpec(magic, magic_len, total_len, total_len,
+                     FrameSpec::FIXED);
+}
+
+static HandshakeCodec MakeTestCodec(std::string* calls = NULL) {
+    HandshakeCodec codec{};
+    codec.protocol_version = 7;
+    codec.hello_frame = FixedSpec("HS", 2, 4);
+    codec.ack_frame = FixedSpec(NULL, 0, 1);
+    codec.build_hello = [calls](bool enabled, std::string* payload) {
+        if (calls) *calls += "build ";
+        *payload = enabled ? "LO" : "NO";
+        return STEP_OK;
+    };
+    codec.parse_hello = [calls](const std::string& payload) {
+        if (calls) *calls += "parse ";
+        return payload == "OK" ? STEP_OK : STEP_FALLBACK;
+    };
+    codec.build_ack = [calls](bool enabled, std::string* payload) {
+        if (calls) *calls += enabled ? "ack1 " : "ack0 ";
+        *payload = enabled ? "1" : "0";
+        return STEP_OK;
+    };
+    codec.parse_ack = [calls](const std::string& payload, bool* enabled) {
+        if (calls) *calls += "parse_ack ";
+        *enabled = payload == "1";
+        return payload == "1" || payload == "0" ? STEP_OK : STEP_ERROR;
+    };
+    return codec;
+}
+
+TEST(HandshakeFrameTest, supports_two_byte_fixed_magic) {
+    const FrameSpec spec = FixedSpec("UB", 2, 6);
+    std::string frame;
+    ASSERT_EQ(FRAME_OK, FrameCodec::Encode(spec, "data", &frame));
+    ASSERT_EQ("UBdata", frame);
+}
+
+TEST(HandshakeFrameTest, encodes_u16_total_length) {
+    const FrameSpec spec(
+        "RDMA", 4, 8, 64, FrameSpec::U16_TOTAL_LENGTH);
+    std::string frame;
+    ASSERT_EQ(FRAME_OK, FrameCodec::Encode(spec, "xy", &frame));
+    ASSERT_EQ(8UL, frame.size());
+    uint16_t total_be = 0;
+    memcpy(&total_be, frame.data() + 4, sizeof(total_be));
+    ASSERT_EQ(8, butil::NetToHost16(total_be));
+    ASSERT_EQ("xy", frame.substr(6));
+}
+
+TEST(HandshakeFrameTest, encodes_u32_body_length) {
+    const FrameSpec spec(
+        "RDM3", 4, 9, 32, FrameSpec::U32_BODY_LENGTH);
+    std::string frame;
+    ASSERT_EQ(FRAME_OK, FrameCodec::Encode(spec, "abc", &frame));
+    uint32_t body_be = 0;
+    memcpy(&body_be, frame.data() + 4, sizeof(body_be));
+    ASSERT_EQ(3U, butil::NetToHost32(body_be));
+    ASSERT_EQ("abc", frame.substr(8));
+}
+
+TEST(HandshakeFrameTest, buffered_partial_frame_is_not_consumed) {
+    const FrameSpec spec(
+        "RDMA", 4, 8, 64, FrameSpec::U16_TOTAL_LENGTH);
+    std::string frame;
+    ASSERT_EQ(FRAME_OK, FrameCodec::Encode(spec, "payload", &frame));
+    butil::IOBuf source;
+    source.append(frame.data(), frame.size() - 1);
+    IOBufHandshakeInput input(&source);
+    std::string payload;
+    ASSERT_EQ(FRAME_NEED_MORE,
+              FrameCodec::ParseBufferedFrame(&input, spec, &payload));
+    ASSERT_EQ(frame.size() - 1, source.size());
+
+    source.append(frame.data() + frame.size() - 1, 1);
+    ASSERT_EQ(FRAME_OK,
+              FrameCodec::ParseBufferedFrame(&input, spec, &payload));
+    ASSERT_EQ("payload", payload);
+    ASSERT_TRUE(source.empty());
 }
 
-TEST(TransportHandshakeTest, reset_clears_terminal_state) {
-    HandshakeSession handshake;
-    handshake.set_protocol_version(3);
-    handshake.MarkEstablished();
-    ASSERT_EQ(ESTABLISHED, handshake.phase());
-    ASSERT_EQ(3, handshake.protocol_version());
+TEST(HandshakeFrameTest, buffered_magic_mismatch_is_not_consumed) {
+    const FrameSpec spec = FixedSpec("UB", 2, 6);
+    butil::IOBuf source;
+    source.append("XXdata", 6);
+    IOBufHandshakeInput input(&source);
+    std::string payload;
+    ASSERT_EQ(FRAME_NOT_MINE,
+              FrameCodec::ParseBufferedFrame(&input, spec, &payload));
+    ASSERT_EQ(6UL, source.size());
+}
+
+TEST(HandshakeFrameTest, blocking_magic_mismatch_is_pushed_back) {
+    MemoryHandshakeIO io("XX");
+    const FrameSpec spec = FixedSpec("UB", 2, 6);
+    std::string payload;
+    ASSERT_EQ(FRAME_NOT_MINE,
+              FrameCodec::ReadFrame(&io, spec, true, &payload));
+    ASSERT_EQ("XX", io.pushed_back());
+}
 
-    handshake.Reset(NULL);
-    ASSERT_EQ(UNINITIALIZED, handshake.phase());
-    ASSERT_EQ(0, handshake.protocol_version());
+TEST(HandshakeFrameTest, rejects_lengths_outside_bounds) {
+    const FrameSpec spec(
+        "RDMA", 4, 8, 16, FrameSpec::U16_TOTAL_LENGTH);
+    std::string header("RDMA", 4);
+    const uint16_t total_be = butil::HostToNet16(17);
+    header.append(reinterpret_cast<const char*>(&total_be), sizeof(total_be));
+    butil::IOBuf source;
+    source.append(header);
+    IOBufHandshakeInput input(&source);
+    std::string payload;
+    ASSERT_EQ(FRAME_PROTOCOL_ERROR,
+              FrameCodec::ParseBufferedFrame(&input, spec, &payload));
+    ASSERT_EQ(header.size(), source.size());
+}
+
+TEST(TransportHandshakeTest, publish_fallback_after_tcp_state) {
+    HandshakeSession session;
+    int tcp_active = 0;
+    session.SetPhase(NEGOTIATING);
+    session.PublishFallback([&tcp_active]() { tcp_active = 1; });
+    ASSERT_EQ(1, tcp_active);
+    ASSERT_EQ(FALLBACK_TCP, session.phase());
 }
 
-TEST(TransportHandshakeTest, client_driver_runs_common_sequence) {
+TEST(TransportHandshakeTest, client_runs_codec_and_resource_sequence) {
+    MemoryHandshakeIO io("HSOK");
     HandshakeSession session;
+    session.SetIOForTest(&io);
     std::string calls;
-    bool high_speed_active = false;
 
     ClientHandshakeCallbacks callbacks{};
     callbacks.phases = HandshakePhases{1, 2, 3, 4, 5, 6};
-    callbacks.prepare_local = [&]() {
+    callbacks.codec = MakeTestCodec(&calls);
+    callbacks.prepare_resources = [&]() {
         calls += "prepare ";
         return STEP_OK;
     };
-    callbacks.send_local_hello = [&]() {
-        calls += "send_hello ";
-        return STEP_OK;
-    };
-    callbacks.receive_remote_hello = [&]() {
-        calls += "recv_hello ";
-        return STEP_OK;
-    };
     callbacks.negotiate_resources = [&]() {
         calls += "negotiate ";
         return STEP_OK;
     };
-    callbacks.send_ack = [&](bool enabled) {
-        EXPECT_TRUE(enabled);
-        calls += "send_ack ";
-        return STEP_OK;
-    };
-    callbacks.set_high_speed_active = [&]() {
-        high_speed_active = true;
-        calls += "activate";
-    };
+    callbacks.set_high_speed_active = [&]() { calls += "activate"; };
     callbacks.set_tcp_active = []() {};
     callbacks.on_failed = []() {};
 
     ASSERT_EQ(STEP_OK, session.RunClient(callbacks));
-    ASSERT_EQ("prepare send_hello recv_hello negotiate send_ack activate",
-              calls);
-    ASSERT_TRUE(high_speed_active);
+    ASSERT_EQ("prepare build parse negotiate ack1 activate", calls);
+    ASSERT_EQ("HSLO1", io.output());
     ASSERT_EQ(ESTABLISHED, session.phase());
+    ASSERT_EQ(7, session.protocol_version());
 }
 
-TEST(TransportHandshakeTest, client_driver_falls_back_after_remote_hello) {
+TEST(TransportHandshakeTest, client_resource_failure_falls_back_before_io) {
+    MemoryHandshakeIO io;
     HandshakeSession session;
-    bool ack_enabled = true;
+    session.SetIOForTest(&io);
     bool tcp_active = false;
 
     ClientHandshakeCallbacks callbacks{};
     callbacks.phases = HandshakePhases{1, 2, 3, 4, 5, 6};
-    callbacks.prepare_local = []() { return STEP_OK; };
-    callbacks.send_local_hello = []() { return STEP_OK; };
-    callbacks.receive_remote_hello = []() { return STEP_FALLBACK; };
-    callbacks.negotiate_resources = []() {
-        ADD_FAILURE() << "resource negotiation must be skipped";
-        return STEP_ERROR;
-    };
-    callbacks.send_ack = [&](bool enabled) {
-        ack_enabled = enabled;
-        return STEP_OK;
-    };
+    callbacks.codec = MakeTestCodec();
+    callbacks.prepare_resources = []() { return STEP_FALLBACK; };
+    callbacks.negotiate_resources = []() { return STEP_ERROR; };
     callbacks.set_high_speed_active = []() {};
     callbacks.set_tcp_active = [&]() { tcp_active = true; };
     callbacks.on_failed = []() {};
 
     ASSERT_EQ(STEP_FALLBACK, session.RunClient(callbacks));
-    ASSERT_FALSE(ack_enabled);
     ASSERT_TRUE(tcp_active);
+    ASSERT_TRUE(io.output().empty());
     ASSERT_EQ(FALLBACK_TCP, session.phase());
 }
 
-TEST(TransportHandshakeTest, server_driver_resumes_at_ack_wait) {
-    HandshakeSession session;
-    int hello_calls = 0;
-    int ack_calls = 0;
-    bool high_speed_active = false;
-
-    ServerHandshakeCallbacks callbacks{};
-    callbacks.phases = HandshakePhases{11, 12, 13, 14, 15, 16};
-    callbacks.fallback_on_not_mine = false;
-    callbacks.receive_remote_hello = [&]() {
-        ++hello_calls;
-        return STEP_OK;
-    };
-    callbacks.prepare_local = []() { return STEP_OK; };
-    callbacks.negotiate_resources = []() { return STEP_OK; };
-    callbacks.send_local_hello = [](bool enabled) {
-        EXPECT_TRUE(enabled);
-        return STEP_OK;
-    };
-    callbacks.receive_ack = [&]() {
-        ++ack_calls;
-        return ack_calls == 1 ? STEP_NEED_MORE : STEP_OK;
-    };
-    callbacks.set_high_speed_active = [&]() {
-        high_speed_active = true;
-    };
-    callbacks.set_tcp_active = []() {};
-    callbacks.on_failed = []() {};
-
-    ASSERT_EQ(STEP_NEED_MORE, session.RunServer(callbacks));
-    ASSERT_EQ(16, session.phase());
-    ASSERT_EQ(1, hello_calls);
-    ASSERT_EQ(1, ack_calls);
-
-    ASSERT_EQ(STEP_OK, session.RunServer(callbacks));
-    ASSERT_EQ(1, hello_calls);
-    ASSERT_EQ(2, ack_calls);
-    ASSERT_TRUE(high_speed_active);
-    ASSERT_EQ(ESTABLISHED, session.phase());
-}
-
-TEST(TransportHandshakeTest, server_driver_runs_blocking_handshake) {
+TEST(TransportHandshakeTest, server_resumes_at_buffered_ack) {
+    MemoryHandshakeIO io;
     HandshakeSession session;
+    session.SetIOForTest(&io);
+    butil::IOBuf source;
+    source.append("HSOK", 4);
+    IOBufHandshakeInput input(&source);
     std::string calls;
 
     ServerHandshakeCallbacks callbacks{};
     callbacks.phases = HandshakePhases{11, 12, 13, 14, 15, 16};
-    callbacks.fallback_on_not_mine = true;
-    callbacks.receive_remote_hello = [&]() {
-        calls += "recv_hello ";
-        return STEP_OK;
-    };
-    callbacks.prepare_local = [&]() {
+    callbacks.fallback_on_not_mine = false;
+    callbacks.codecs.push_back(MakeTestCodec(&calls));
+    callbacks.input = &input;
+    callbacks.prepare_resources = [&]() {
         calls += "prepare ";
         return STEP_OK;
     };
@@ -177,44 +260,83 @@ TEST(TransportHandshakeTest, server_driver_runs_blocking_handshake) {
         calls += "negotiate ";
         return STEP_OK;
     };
-    callbacks.send_local_hello = [&](bool enabled) {
-        EXPECT_TRUE(enabled);
-        calls += "send_hello ";
-        return STEP_OK;
-    };
-    callbacks.receive_ack = [&]() {
-        calls += "recv_ack ";
+    callbacks.validate_established = [&]() {
+        calls += "validate ";
         return STEP_OK;
     };
     callbacks.set_high_speed_active = [&]() { calls += "activate"; };
     callbacks.set_tcp_active = []() {};
     callbacks.on_failed = []() {};
 
+    ASSERT_EQ(STEP_NEED_MORE, session.RunServer(callbacks));
+    ASSERT_EQ(16, session.phase());
+    ASSERT_EQ("HSLO", io.output());
+    ASSERT_TRUE(source.empty());
+
+    source.append("1", 1);
     ASSERT_EQ(STEP_OK, session.RunServer(callbacks));
-    ASSERT_EQ("recv_hello prepare negotiate send_hello recv_ack activate",
+    ASSERT_EQ("parse prepare negotiate build parse_ack validate activate",
               calls);
     ASSERT_EQ(ESTABLISHED, session.phase());
 }
 
-TEST(TransportHandshakeTest, server_driver_falls_back_for_other_protocol) {
+TEST(TransportHandshakeTest, server_falls_back_without_consuming_other_magic) {
+    MemoryHandshakeIO io;
     HandshakeSession session;
+    session.SetIOForTest(&io);
+    butil::IOBuf source;
+    source.append("XXok", 4);
+    IOBufHandshakeInput input(&source);
     bool tcp_active = false;
 
     ServerHandshakeCallbacks callbacks{};
     callbacks.phases = HandshakePhases{11, 12, 13, 14, 15, 16};
     callbacks.fallback_on_not_mine = true;
-    callbacks.receive_remote_hello = []() { return STEP_NOT_MINE; };
-    callbacks.prepare_local = []() { return STEP_ERROR; };
+    callbacks.codecs.push_back(MakeTestCodec());
+    callbacks.input = &input;
+    callbacks.prepare_resources = []() { return STEP_ERROR; };
     callbacks.negotiate_resources = []() { return STEP_ERROR; };
-    callbacks.send_local_hello = [](bool) { return STEP_ERROR; };
-    callbacks.receive_ack = []() { return STEP_ERROR; };
     callbacks.set_high_speed_active = []() {};
     callbacks.set_tcp_active = [&]() { tcp_active = true; };
     callbacks.on_failed = []() {};
 
     ASSERT_EQ(STEP_FALLBACK, session.RunServer(callbacks));
     ASSERT_TRUE(tcp_active);
+    ASSERT_EQ(4UL, source.size());
     ASSERT_EQ(FALLBACK_TCP, session.phase());
+
+    ASSERT_EQ(STEP_NOT_MINE, session.RunServer(callbacks));
+    ASSERT_EQ(4UL, source.size());
+    ASSERT_EQ(FALLBACK_TCP, session.phase());
+}
+
+TEST(TransportHandshakeTest, server_enters_hello_phase_after_magic_matches) {
+    MemoryHandshakeIO io;
+    HandshakeSession session;
+    session.SetIOForTest(&io);
+    butil::IOBuf source;
+    IOBufHandshakeInput input(&source);
+
+    ServerHandshakeCallbacks callbacks{};
+    callbacks.phases = HandshakePhases{11, 12, 13, 14, 15, 16};
+    callbacks.fallback_on_not_mine = false;
+    callbacks.codecs.push_back(MakeTestCodec());
+    callbacks.input = &input;
+    callbacks.prepare_resources = []() { return STEP_OK; };
+    callbacks.negotiate_resources = []() { return STEP_OK; };
+    callbacks.set_high_speed_active = []() {};
+    callbacks.set_tcp_active = []() {};
+    callbacks.on_failed = []() {};
+
+    source.append("H", 1);
+    ASSERT_EQ(STEP_NEED_MORE, session.RunServer(callbacks));
+    ASSERT_EQ(UNINITIALIZED, session.phase());
+
+    source.append("S", 1);
+    ASSERT_EQ(STEP_NEED_MORE, session.RunServer(callbacks));
+    ASSERT_EQ(13, session.phase());
+    ASSERT_EQ(7, session.protocol_version());
+    ASSERT_EQ(2UL, source.size());
 }
 
 }  // namespace handshake

From 154f23229c9c03f2623793af00e678e7e16718fa Mon Sep 17 00:00:00 2001
From: Gzure <740684863@qq.com>
Date: Wed, 19 Aug 2026 11:25:19 +0800
Subject: [PATCH 08/11] Move RDMA server handshake into common adapter

---
 docs/cn/handshake_common_design.md            |  46 +++-
 src/brpc/handshake/handshake_adapter.cpp      |  49 ++++
 src/brpc/handshake/handshake_adapter.h        |  74 ++++++
 src/brpc/{ => handshake}/rdma_handshake.cpp   | 226 +++++++++++++++++-
 src/brpc/{ => handshake}/rdma_handshake.h     |  21 +-
 .../rdma_handshake_constants.h                |   6 +-
 src/brpc/policy/rdma_handshake_protocol.cpp   |   5 +-
 src/brpc/rdma_handshake_server.cpp            | 143 -----------
 src/brpc/rdma_handshake_server.h              |  44 ----
 src/brpc/rdma_transport.cpp                   |  83 +------
 src/brpc/rdma_transport.h                     |   6 +-
 test/brpc_rdma_unittest.cpp                   |   6 +-
 12 files changed, 411 insertions(+), 298 deletions(-)
 create mode 100644 src/brpc/handshake/handshake_adapter.cpp
 create mode 100644 src/brpc/handshake/handshake_adapter.h
 rename src/brpc/{ => handshake}/rdma_handshake.cpp (62%)
 rename src/brpc/{ => handshake}/rdma_handshake.h (89%)
 rename src/brpc/{ => handshake}/rdma_handshake_constants.h (95%)
 delete mode 100644 src/brpc/rdma_handshake_server.cpp
 delete mode 100644 src/brpc/rdma_handshake_server.h

diff --git a/docs/cn/handshake_common_design.md b/docs/cn/handshake_common_design.md
index 5fcfbc5d36..0b3869e2ab 100644
--- a/docs/cn/handshake_common_design.md
+++ b/docs/cn/handshake_common_design.md
@@ -43,9 +43,9 @@ RDMA 支持：
 
 相关代码：
 
-- `src/brpc/rdma_handshake.h`
-- `src/brpc/rdma_handshake.cpp`
-- `src/brpc/rdma_handshake_server.cpp`
+- `src/brpc/handshake/handshake_adapter.*`
+- `src/brpc/handshake/rdma_handshake.*`
+- `src/brpc/handshake/rdma_handshake_constants.h`
 
 ### 2.2 URMA
 
@@ -120,10 +120,10 @@ Hello 中携带：
 src/brpc/
     adapter_transport.h/.cpp     # Socket 顶层 Transport、TCP-first 路由与状态发布
     transport_handshake.h/.cpp   # HandshakeSession、codec 与资源阶段编排
+    handshake/handshake_adapter.* # 标准 server parser 适配与 ParseResult 转换
     handshake/handshake_io.*     # blocking fd I/O 与增量 IOBuf 输入适配
     handshake/handshake_frame.*  # fixed/U16/U32 通用 framing
-    rdma_handshake.h/.cpp        # RDMA v2/v3 payload 字段 adapter
-    rdma_handshake_server.h/.cpp # RDMA 标准 server parser，fallback 复用 Session/FrameCodec
+    handshake/rdma_handshake.*   # RDMA v2/v3 字段与 server handshake adapter
     rdma_handshake.proto         # RDMA v3 wire message
     rdma_transport.h/.cpp        # 独立 RDMA Transport、握手回调与数据面
     ubshm_transport.h/.cpp       # 独立 UBSHM Transport、握手回调与数据面
@@ -318,7 +318,7 @@ public:
 - client：通过 `SocketHandshakeIO` 统一执行 blocking fd 读写；
 - server：把 `butil::IOBuf` 封装成 `IOBufHandshakeInput`；
 - UBSHM 当前 server 也使用 fd 读取，可先使用 `SocketHandshakeIO`，后续再迁移到增量解析；
-- RDMA 的 `rdma_handshake_server.cpp` 可以直接使用 `HandshakeInput`。
+- RDMA 的 `RdmaServerHandshakeAdapter` 直接使用 `HandshakeInput`。
 
 ### 5.3 FrameCodec
 
@@ -393,6 +393,26 @@ struct ClientHandshakeCallbacks {
 };
 ```
 
+标准 server parser 通过一个更深的 adapter seam 接入。policy parser 只调用
+`ExecuteServerHandshake`。`StandardHandshakeAdapter` 统一处理 `StepResult` 到
+`ParseResult` 的转换、`ACK_WAIT` parsing context 和终态清理，协议通常只实现
+三个 protected hook；确实无法复用标准 parser 生命周期时，可以直接实现最小
+`HandshakeAdapter` interface：
+
+```cpp
+class HandshakeAdapter {
+public:
+    virtual ParseResult ExecuteServerHandshake(IOBuf*, Socket*) = 0;
+};
+
+class StandardHandshakeAdapter : public HandshakeAdapter {
+protected:
+    virtual StepResult RunServerHandshake(IOBuf*, Socket*) = 0;
+    virtual HandshakeSession* GetSession(Socket*) const = 0;
+    virtual int AckWaitPhase(const Socket*) const = 0;
+};
+```
+
 这样公共头文件不包含 `ibv_*`、`urma_*` 或 UBRING 类型；RDMA 的 `ParsedHello`、URMA 的 Jetty 参数和 UBSHM 的共享内存描述仍由各自 callback 捕获。
 
 ## 6. HandshakeSession 状态机
@@ -524,7 +544,7 @@ class AdapterTransport : public Transport {
 
 class RdmaTransport : public Transport {
     RdmaEndpoint* _endpoint;
-    // 每次升级尝试创建一个 RdmaHandshakeAdapter。
+    // client 每次升级尝试创建字段 adapter；server 由公共 adapter 驱动。
 };
 
 class UrmaTransport : public Transport {
@@ -734,6 +754,9 @@ classDiagram
         +MarkFailed()
     }
     class RdmaTransport
+    class HandshakeAdapter
+    class StandardHandshakeAdapter
+    class RdmaServerHandshakeAdapter
     class RdmaHandshakeAdapter
     class HandshakeCodec
     class FrameCodec
@@ -754,6 +777,10 @@ classDiagram
     HandshakeSession *-- SocketHandshakeIO
     HandshakeSession --> FrameCodec
     HandshakeSession o-- HandshakeCodec
+    HandshakeAdapter <|-- StandardHandshakeAdapter
+    StandardHandshakeAdapter <|-- RdmaServerHandshakeAdapter
+    RdmaServerHandshakeAdapter --> HandshakeSession
+    RdmaServerHandshakeAdapter --> RdmaHandshakeAdapter
     RdmaTransport --> RdmaHandshakeAdapter
     RdmaTransport --> HighSpeedEndpoint
     UBShmTransport --> HighSpeedEndpoint
@@ -761,7 +788,7 @@ classDiagram
 
 `AdapterTransport` 是安装在 `Socket` 上的最上层 TCP-first Transport：`UNINITIALIZED/NEGOTIATING/FALLBACK_TCP` 都委托给 `TcpTransport`，仅当 `HandshakeSession` release 发布 `ESTABLISHED` 后才委托给所选的 RDMA/URMA/UBSHM Transport。成功升级后的 TCP 控制连接只允许 EOF，不再接受应用数据。
 
-`HandshakeSession::RunClient/RunServer` 持有 `HandshakeCodec` 并统一执行 framing、Hello/ACK 收发、字段 codec 调用、资源准备/协商回调以及 established/fallback/failed 发布。RDMA/UBSHM callback 只解析协议字段或执行具体资源动作；RDMA server 的 `STEP_NEED_MORE` 仍由 bRPC 标准 parser 增量驱动，UBSHM server 使用同一驱动的 blocking 模式。
+`HandshakeSession::RunClient/RunServer` 持有 `HandshakeCodec` 并统一执行 framing、Hello/ACK 收发、字段 codec 调用、资源准备/协商回调以及 established/fallback/failed 发布。`StandardHandshakeAdapter::ExecuteServerHandshake` 统一桥接 bRPC 标准 parser；`RdmaServerHandshakeAdapter` 组装 RDMA 或 plain-TCP fallback callback。RDMA/UBSHM callback 只解析协议字段或执行具体资源动作；RDMA server 的 `STEP_NEED_MORE` 仍由标准 parser 增量驱动，UBSHM server 使用同一 Session driver 的 blocking 模式。
 
 ### 14.1 当前完成度
 
@@ -769,10 +796,11 @@ classDiagram
 |---|---|---|
 | TCP-first 路由 | 已实现 | `Socket` 持有顶层 `AdapterTransport`；其组合 `TcpTransport` 和一个独立高速 `Transport` |
 | 公共握手处理 | 已实现 | `RunClient/RunServer` 统一 FrameCodec、字段 codec、资源回调、ACK、fallback 和错误流程 |
-| RDMA client/server | 已迁移 | v2/v3 adapter 只编解码 payload 字段；真实 RDMA 与无 RDMA Endpoint 的 server fallback 都由 Session 处理 framing/ACK；server 保留 #3350 的标准增量解析流程 |
+| RDMA client/server | 已迁移 | adapter、wire 常量和 server executor 位于 `src/brpc/handshake`；真实 RDMA 与无 RDMA Endpoint 的 fallback 共用 `HandshakeAdapter/Session`；server 保留 #3350 的标准增量解析流程 |
 | UBSHM client/server | 已迁移 | 固定 64 字节 framing、2 字节 magic、ACK 和 fd I/O 已进入公共组件；server 当前仍使用 blocking 输入 |
 | URMA | 待迁移 | origin/master 暂无受版本控制的 URMA Transport；合入后保留独立 `UrmaTransport`，由顶层 `AdapterTransport` 组合并复用 `HandshakeSession` |
 | RDMA Protocol adapter | 已实现 | `RdmaHandshakeAdapter` 只构造/解析 v2/v3 payload 字段，不再读写 fd 或消费 `IOBuf` |
+| Server parser adapter | 已实现 | `HandshakeAdapter` 抽象唯一入口；`StandardHandshakeAdapter` 统一 ParseResult、ACK_WAIT context 和清理流程；协议只实现 driver hook |
 | 通用 FrameCodec | 已实现 | 支持 fixed、U16 总长度、U32 body 长度、2/4 字节 magic、blocking I/O 和增量 `IOBuf` 解析 |
 
 ### 14.2 必须继承的修复语义
diff --git a/src/brpc/handshake/handshake_adapter.cpp b/src/brpc/handshake/handshake_adapter.cpp
new file mode 100644
index 0000000000..501b71cc45
--- /dev/null
+++ b/src/brpc/handshake/handshake_adapter.cpp
@@ -0,0 +1,49 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "brpc/handshake/handshake_adapter.h"
+
+#include "brpc/socket.h"
+
+namespace brpc {
+namespace handshake {
+
+// InputMessenger may call this entry repeatedly while bytes arrive. Keep all
+// connection state in HandshakeSession and Socket rather than in the adapter,
+// so a single stateless adapter can serve every connection. The parsing
+// context is only a marker that keeps InputMessenger on the selected protocol
+// between the server hello and the peer ACK.
+ParseResult StandardHandshakeAdapter::ExecuteServerHandshake(
+    butil::IOBuf* source, Socket* socket) {
+    const StepResult result = RunServerHandshake(source, socket);
+    if (result == STEP_NEED_MORE) {
+        if (GetSession(socket)->phase() == AckWaitPhase(socket) &&
+            socket->parsing_context() == NULL) {
+            socket->reset_parsing_context(ServerHandshakeContext::Create());
+        }
+        return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
+    }
+
+    socket->reset_parsing_context(NULL);
+    if (result == STEP_ERROR) {
+        return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
+    }
+    return MakeParseError(PARSE_ERROR_TRY_OTHERS);
+}
+
+}  // namespace handshake
+}  // namespace brpc
diff --git a/src/brpc/handshake/handshake_adapter.h b/src/brpc/handshake/handshake_adapter.h
new file mode 100644
index 0000000000..b85d883602
--- /dev/null
+++ b/src/brpc/handshake/handshake_adapter.h
@@ -0,0 +1,74 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#ifndef BRPC_HANDSHAKE_HANDSHAKE_ADAPTER_H
+#define BRPC_HANDSHAKE_HANDSHAKE_ADAPTER_H
+
+#include "butil/macros.h"
+#include "brpc/parse_result.h"
+#include "brpc/transport_handshake.h"
+
+namespace butil {
+class IOBuf;
+}
+
+namespace brpc {
+
+class Socket;
+
+namespace handshake {
+
+// The minimal seam between an upgrade protocol and InputMessenger. Protocols
+// that cannot use the standard parser lifecycle implement this interface
+// directly.
+class HandshakeAdapter {
+public:
+    virtual ~HandshakeAdapter() = default;
+
+    virtual ParseResult ExecuteServerHandshake(
+        butil::IOBuf* source, Socket* socket) = 0;
+
+protected:
+    HandshakeAdapter() = default;
+
+private:
+    DISALLOW_COPY_AND_ASSIGN(HandshakeAdapter);
+};
+
+// Reusable InputMessenger implementation. Protocols normally derive from this
+// class and provide only the Session driver and phase hooks.
+class StandardHandshakeAdapter : public HandshakeAdapter {
+public:
+    ParseResult ExecuteServerHandshake(
+        butil::IOBuf* source, Socket* socket) override;
+
+protected:
+    StandardHandshakeAdapter() = default;
+
+    virtual StepResult RunServerHandshake(
+        butil::IOBuf* source, Socket* socket) = 0;
+    virtual HandshakeSession* GetSession(Socket* socket) const = 0;
+    virtual int AckWaitPhase(const Socket* socket) const = 0;
+
+private:
+    DISALLOW_COPY_AND_ASSIGN(StandardHandshakeAdapter);
+};
+
+}  // namespace handshake
+}  // namespace brpc
+
+#endif  // BRPC_HANDSHAKE_HANDSHAKE_ADAPTER_H
diff --git a/src/brpc/rdma_handshake.cpp b/src/brpc/handshake/rdma_handshake.cpp
similarity index 62%
rename from src/brpc/rdma_handshake.cpp
rename to src/brpc/handshake/rdma_handshake.cpp
index 8999e810b2..ccf8833f6b 100644
--- a/src/brpc/rdma_handshake.cpp
+++ b/src/brpc/handshake/rdma_handshake.cpp
@@ -15,20 +15,27 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#if BRPC_WITH_RDMA
-
-#include "brpc/rdma_handshake.h"
+#include "brpc/handshake/rdma_handshake.h"
 
 #include <errno.h>
-#include <cstring>
 #include <limits>
 #include <string>
 
-#include <gflags/gflags.h>
-
+#include "butil/logging.h"
 #include "butil/raw_pack.h"
 #include "butil/sys_byteorder.h"
+#include "brpc/adapter_transport.h"
+#include "brpc/handshake/rdma_handshake_constants.h"
 #include "brpc/rdma_handshake.pb.h"
+#include "brpc/socket.h"
+
+#if BRPC_WITH_RDMA
+
+#include <cstring>
+
+#include <gflags/gflags.h>
+
+#include "brpc/rdma_transport.h"
 
 namespace brpc {
 namespace rdma {
@@ -383,3 +390,210 @@ CreateServerHandshakeAdapters(RdmaEndpoint* ep) {
 }  // namespace brpc
 
 #endif  // BRPC_WITH_RDMA
+
+namespace brpc {
+namespace handshake {
+
+class RdmaServerHandshakeAdapter : public StandardHandshakeAdapter {
+public:
+    RdmaServerHandshakeAdapter() = default;
+
+protected:
+    StepResult RunServerHandshake(
+        butil::IOBuf* source, Socket* socket) override;
+    HandshakeSession* GetSession(Socket* socket) const override;
+    int AckWaitPhase(const Socket* socket) const override;
+
+private:
+    StepResult RunFallbackServerHandshake(
+        butil::IOBuf* source, Socket* socket);
+#if BRPC_WITH_RDMA
+    StepResult RunRdmaServerHandshake(
+        butil::IOBuf* source, Socket* socket);
+#endif
+
+    DISALLOW_COPY_AND_ASSIGN(RdmaServerHandshakeAdapter);
+};
+
+static const int FALLBACK_PREPARE = 1;
+static const int FALLBACK_HELLO_SEND = 2;
+static const int FALLBACK_HELLO_WAIT = 3;
+static const int FALLBACK_NEGOTIATE = 4;
+static const int FALLBACK_ACK_SEND = 5;
+static const int FALLBACK_ACK_WAIT = 6;
+static constexpr uint16_t V2_HELLO_VERSION_INVALID =
+    std::numeric_limits<uint16_t>::max();
+static constexpr size_t V3_GID_LEN = 16;
+
+static HandshakeCodec MakeRdmaFallbackCodec(int version) {
+    HandshakeCodec codec{};
+    codec.protocol_version = version;
+    codec.hello_frame = rdma::RdmaHelloFrameSpec(version);
+    codec.ack_frame = rdma::RdmaAckFrameSpec();
+    codec.parse_hello = [](const std::string&) {
+        return STEP_FALLBACK;
+    };
+    codec.build_hello = [version](bool enabled, std::string* payload) {
+        if (enabled) {
+            errno = EPROTO;
+            return STEP_ERROR;
+        }
+        if (version == 2) {
+            payload->assign(
+                rdma::HELLO_V2_MSG_LEN_MIN - rdma::HELLO_MAGIC_LEN -
+                    sizeof(uint16_t),
+                '\0');
+            butil::RawPacker(&(*payload)[0])
+                .pack16(V2_HELLO_VERSION_INVALID);
+            return STEP_OK;
+        }
+
+        rdma::RdmaHello reply;
+        reply.set_block_size(0);
+        reply.set_sq_size(0);
+        reply.set_rq_size(0);
+        reply.set_lid(0);
+        reply.set_gid(std::string(V3_GID_LEN, '\0'));
+        reply.set_qp_num(0);
+        if (!reply.SerializeToString(payload)) {
+            errno = EPROTO;
+            return STEP_ERROR;
+        }
+        return STEP_OK;
+    };
+    codec.build_ack = [](bool enabled, std::string* payload) {
+        const uint32_t flags_be = butil::HostToNet32(
+            enabled ? rdma::HELLO_ACK_RDMA_OK : 0);
+        payload->assign(reinterpret_cast<const char*>(&flags_be),
+                        sizeof(flags_be));
+        return STEP_OK;
+    };
+    codec.parse_ack = [](const std::string& payload, bool* enabled) {
+        if (payload.size() != rdma::HELLO_ACK_LEN) {
+            errno = EPROTO;
+            return STEP_ERROR;
+        }
+        *enabled = false;
+        return STEP_OK;
+    };
+    return codec;
+}
+
+HandshakeAdapter* GetRdmaServerHandshakeAdapter() {
+    static RdmaServerHandshakeAdapter adapter;
+    return &adapter;
+}
+
+HandshakeSession* RdmaServerHandshakeAdapter::GetSession(
+    Socket* socket) const {
+    return AdapterTransport::Get(socket)->handshake_session();
+}
+
+int RdmaServerHandshakeAdapter::AckWaitPhase(const Socket* socket) const {
+#if BRPC_WITH_RDMA
+    if (socket->socket_mode() == SOCKET_MODE_RDMA) {
+        return RdmaTransport::S_ACK_WAIT;
+    }
+#endif
+    return FALLBACK_ACK_WAIT;
+}
+
+StepResult RdmaServerHandshakeAdapter::RunFallbackServerHandshake(
+    butil::IOBuf* source, Socket* socket) {
+    IOBufHandshakeInput input(source);
+    ServerHandshakeCallbacks callbacks{};
+    callbacks.phases = HandshakePhases{
+        FALLBACK_PREPARE, FALLBACK_HELLO_SEND, FALLBACK_HELLO_WAIT,
+        FALLBACK_NEGOTIATE, FALLBACK_ACK_SEND, FALLBACK_ACK_WAIT};
+    callbacks.fallback_on_not_mine = false;
+    callbacks.codecs.push_back(MakeRdmaFallbackCodec(2));
+    callbacks.codecs.push_back(MakeRdmaFallbackCodec(3));
+    callbacks.input = &input;
+    callbacks.prepare_resources = []() { return STEP_OK; };
+    callbacks.negotiate_resources = []() { return STEP_OK; };
+    callbacks.set_high_speed_active = []() {};
+    callbacks.set_tcp_active = []() {};
+    callbacks.on_failed = []() {};
+    return GetSession(socket)->RunServer(callbacks);
+}
+
+#if BRPC_WITH_RDMA
+StepResult RdmaServerHandshakeAdapter::RunRdmaServerHandshake(
+    butil::IOBuf* source, Socket* socket) {
+    RdmaTransport* transport = RdmaTransport::Get(socket);
+    rdma::RdmaEndpoint* ep = transport->_rdma_ep;
+    CHECK(ep != NULL);
+
+    rdma::ParsedHello remote{};
+    std::vector<std::unique_ptr<rdma::RdmaHandshakeAdapter> > protocols =
+        rdma::CreateServerHandshakeAdapters(ep);
+    IOBufHandshakeInput input(source);
+    ServerHandshakeCallbacks callbacks{};
+    callbacks.phases = HandshakePhases{
+        RdmaTransport::S_ALLOC_QPCQ, RdmaTransport::S_HELLO_SEND,
+        RdmaTransport::S_HELLO_WAIT, RdmaTransport::S_BRINGUP_QP,
+        0, RdmaTransport::S_ACK_WAIT};
+    callbacks.fallback_on_not_mine = false;
+    callbacks.input = &input;
+    for (size_t i = 0; i < protocols.size(); ++i) {
+        HandshakeCodec codec = protocols[i]->MakeCodec(&remote);
+        const std::function<StepResult(const std::string&)> parse_hello =
+            codec.parse_hello;
+        codec.parse_hello = [transport, parse_hello](
+            const std::string& payload) {
+            const StepResult result = parse_hello(payload);
+            if (result == STEP_FALLBACK) {
+                transport->_rdma_state = RdmaTransport::RDMA_OFF;
+            }
+            return result;
+        };
+        callbacks.codecs.push_back(codec);
+    }
+    callbacks.prepare_resources = [&]() {
+        ep->ApplyRemoteInfo(remote);
+        if (ep->AllocateResources() < 0) {
+            PLOG(WARNING)
+                << "Fail to allocate rdma resources, fallback to tcp:"
+                << socket->description();
+            transport->_rdma_state = RdmaTransport::RDMA_OFF;
+            return STEP_FALLBACK;
+        }
+        return STEP_OK;
+    };
+    callbacks.negotiate_resources = [&]() {
+        if (ep->BringUpQp(remote, true) < 0) {
+            transport->_rdma_state = RdmaTransport::RDMA_OFF;
+            return STEP_FALLBACK;
+        }
+        return STEP_OK;
+    };
+    callbacks.validate_established = [&]() {
+        if (!source->empty() ||
+            transport->_rdma_state == RdmaTransport::RDMA_OFF) {
+            return STEP_ERROR;
+        }
+        return STEP_OK;
+    };
+    callbacks.set_high_speed_active = [transport]() {
+        transport->SetHighSpeedAvailable(true);
+    };
+    callbacks.set_tcp_active = [transport]() {
+        transport->SetHighSpeedAvailable(false);
+    };
+    callbacks.on_failed = []() {};
+    return GetSession(socket)->RunServer(callbacks);
+}
+#endif
+
+StepResult RdmaServerHandshakeAdapter::RunServerHandshake(
+    butil::IOBuf* source, Socket* socket) {
+#if BRPC_WITH_RDMA
+    if (socket->socket_mode() == SOCKET_MODE_RDMA) {
+        return RunRdmaServerHandshake(source, socket);
+    }
+#endif
+    return RunFallbackServerHandshake(source, socket);
+}
+
+}  // namespace handshake
+}  // namespace brpc
diff --git a/src/brpc/rdma_handshake.h b/src/brpc/handshake/rdma_handshake.h
similarity index 89%
rename from src/brpc/rdma_handshake.h
rename to src/brpc/handshake/rdma_handshake.h
index 67112c0afa..71e9067820 100644
--- a/src/brpc/rdma_handshake.h
+++ b/src/brpc/handshake/rdma_handshake.h
@@ -15,8 +15,21 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#ifndef BRPC_RDMA_HANDSHAKE_H
-#define BRPC_RDMA_HANDSHAKE_H
+#ifndef BRPC_HANDSHAKE_RDMA_HANDSHAKE_H
+#define BRPC_HANDSHAKE_RDMA_HANDSHAKE_H
+
+#include "brpc/handshake/handshake_adapter.h"
+
+namespace brpc {
+namespace handshake {
+
+// Returns the single adapter used by policy::ParseRdmaHandshake. The concrete
+// RDMA type is private to the implementation; callers only learn the common
+// HandshakeAdapter interface.
+HandshakeAdapter* GetRdmaServerHandshakeAdapter();
+
+}  // namespace handshake
+}  // namespace brpc
 
 #if BRPC_WITH_RDMA
 
@@ -29,7 +42,7 @@
 #include "butil/containers/optional.h"
 #include "butil/macros.h"
 #include "brpc/rdma/rdma_endpoint.h"
-#include "brpc/rdma_handshake_constants.h"
+#include "brpc/handshake/rdma_handshake_constants.h"
 #include "brpc/transport_handshake.h"
 
 namespace brpc {
@@ -138,4 +151,4 @@ CreateServerHandshakeAdapters(RdmaEndpoint* ep);
 }  // namespace brpc
 
 #endif  // BRPC_WITH_RDMA
-#endif  // BRPC_RDMA_HANDSHAKE_H
+#endif  // BRPC_HANDSHAKE_RDMA_HANDSHAKE_H
diff --git a/src/brpc/rdma_handshake_constants.h b/src/brpc/handshake/rdma_handshake_constants.h
similarity index 95%
rename from src/brpc/rdma_handshake_constants.h
rename to src/brpc/handshake/rdma_handshake_constants.h
index 2041a5e2da..af60d2e9d3 100644
--- a/src/brpc/rdma_handshake_constants.h
+++ b/src/brpc/handshake/rdma_handshake_constants.h
@@ -15,8 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#ifndef BRPC_RDMA_HANDSHAKE_CONSTANTS_H
-#define BRPC_RDMA_HANDSHAKE_CONSTANTS_H
+#ifndef BRPC_HANDSHAKE_RDMA_HANDSHAKE_CONSTANTS_H
+#define BRPC_HANDSHAKE_RDMA_HANDSHAKE_CONSTANTS_H
 
 #include <cstddef>
 #include <cstdint>
@@ -78,4 +78,4 @@ inline const handshake::FrameSpec& RdmaAckFrameSpec() {
 }  // namespace rdma
 }  // namespace brpc
 
-#endif  // BRPC_RDMA_HANDSHAKE_CONSTANTS_H
+#endif  // BRPC_HANDSHAKE_RDMA_HANDSHAKE_CONSTANTS_H
diff --git a/src/brpc/policy/rdma_handshake_protocol.cpp b/src/brpc/policy/rdma_handshake_protocol.cpp
index 3a00610ad3..d948dc6686 100644
--- a/src/brpc/policy/rdma_handshake_protocol.cpp
+++ b/src/brpc/policy/rdma_handshake_protocol.cpp
@@ -19,14 +19,15 @@
 
 #include "butil/logging.h"
 #include "brpc/destroyable.h"
-#include "brpc/rdma_handshake_server.h"
+#include "brpc/handshake/rdma_handshake.h"
 
 namespace brpc {
 namespace policy {
 
 ParseResult ParseRdmaHandshake(butil::IOBuf* source, Socket* socket,
                                bool /*read_eof*/, const void* /*arg*/) {
-    return rdma::ExecuteServerHandshake(source, socket);
+    return handshake::GetRdmaServerHandshakeAdapter()
+        ->ExecuteServerHandshake(source, socket);
 }
 
 void ProcessRdmaHandshake(InputMessageBase* msg) {
diff --git a/src/brpc/rdma_handshake_server.cpp b/src/brpc/rdma_handshake_server.cpp
deleted file mode 100644
index 483156c8d6..0000000000
--- a/src/brpc/rdma_handshake_server.cpp
+++ /dev/null
@@ -1,143 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#include "brpc/rdma_handshake_server.h"
-
-#include <errno.h>
-#include <limits>
-#include <string>
-
-#include "butil/raw_pack.h"
-#include "butil/sys_byteorder.h"
-#include "brpc/adapter_transport.h"
-#include "brpc/rdma_handshake.pb.h"
-#include "brpc/rdma_handshake_constants.h"
-#include "brpc/socket.h"
-#if BRPC_WITH_RDMA
-#include "brpc/rdma_transport.h"
-#endif
-
-namespace brpc {
-namespace rdma {
-
-// Fallback-only field codecs for connections that do not own an
-// RdmaEndpoint. Framing, incremental input, ACK handling, and state are still
-// driven by HandshakeSession, exactly like the real RDMA server handshake.
-static constexpr uint16_t V2_HELLO_VERSION_INVALID =
-    std::numeric_limits<uint16_t>::max();
-static constexpr size_t V3_GID_LEN = 16;
-
-static handshake::HandshakeCodec MakeFallbackCodec(int version) {
-    handshake::HandshakeCodec codec{};
-    codec.protocol_version = version;
-    codec.hello_frame = RdmaHelloFrameSpec(version);
-    codec.ack_frame = RdmaAckFrameSpec();
-    codec.parse_hello = [](const std::string&) {
-        return handshake::STEP_FALLBACK;
-    };
-    codec.build_hello = [version](bool enabled, std::string* payload) {
-        if (enabled) {
-            errno = EPROTO;
-            return handshake::STEP_ERROR;
-        }
-        if (version == 2) {
-            // FrameCodec emits magic and msg_len. The protocol payload starts
-            // at hello_ver and deliberately advertises an invalid version.
-            payload->assign(
-                HELLO_V2_MSG_LEN_MIN - HELLO_MAGIC_LEN - sizeof(uint16_t),
-                '\0');
-            butil::RawPacker(&(*payload)[0])
-                .pack16(V2_HELLO_VERSION_INVALID);
-            return handshake::STEP_OK;
-        }
-
-        RdmaHello reply;
-        reply.set_block_size(0);
-        reply.set_sq_size(0);
-        reply.set_rq_size(0);
-        reply.set_lid(0);
-        reply.set_gid(std::string(V3_GID_LEN, '\0'));
-        reply.set_qp_num(0);
-        if (!reply.SerializeToString(payload)) {
-            errno = EPROTO;
-            return handshake::STEP_ERROR;
-        }
-        return handshake::STEP_OK;
-    };
-    codec.build_ack = [](bool enabled, std::string* payload) {
-        const uint32_t flags_be = butil::HostToNet32(
-            enabled ? HELLO_ACK_RDMA_OK : 0);
-        payload->assign(reinterpret_cast<const char*>(&flags_be),
-                        sizeof(flags_be));
-        return handshake::STEP_OK;
-    };
-    codec.parse_ack = [](const std::string& payload, bool* enabled) {
-        if (payload.size() != HELLO_ACK_LEN) {
-            errno = EPROTO;
-            return handshake::STEP_ERROR;
-        }
-        // This server cannot upgrade, so any well-framed ACK completes the
-        // downgrade. A conforming peer sends zero after the disabled hello.
-        *enabled = false;
-        return handshake::STEP_OK;
-    };
-    return codec;
-}
-
-static ParseResult FallbackServerHandshake(
-    butil::IOBuf* source, Socket* socket) {
-    AdapterTransport* adapter = AdapterTransport::Get(socket);
-    handshake::IOBufHandshakeInput input(source);
-    handshake::ServerHandshakeCallbacks callbacks{};
-    callbacks.phases = handshake::HandshakePhases{1, 2, 3, 4, 5, 6};
-    callbacks.fallback_on_not_mine = false;
-    callbacks.codecs.push_back(MakeFallbackCodec(2));
-    callbacks.codecs.push_back(MakeFallbackCodec(3));
-    callbacks.input = &input;
-    callbacks.prepare_resources = []() { return handshake::STEP_OK; };
-    callbacks.negotiate_resources = []() { return handshake::STEP_OK; };
-    callbacks.set_high_speed_active = []() {};
-    callbacks.set_tcp_active = []() {};
-    callbacks.on_failed = []() {};
-
-    const handshake::StepResult result =
-        adapter->handshake_session()->RunServer(callbacks);
-    if (result == handshake::STEP_NEED_MORE) {
-        if (adapter->handshake_phase() == callbacks.phases.ack_wait &&
-            socket->parsing_context() == NULL) {
-            socket->reset_parsing_context(ServerHandshakeContext::Create());
-        }
-        return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
-    }
-    socket->reset_parsing_context(NULL);
-    if (result == handshake::STEP_ERROR) {
-        return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
-    }
-    return MakeParseError(PARSE_ERROR_TRY_OTHERS);
-}
-
-ParseResult ExecuteServerHandshake(butil::IOBuf* source, Socket* socket) {
-#if BRPC_WITH_RDMA
-    if (socket->socket_mode() == SOCKET_MODE_RDMA) {
-        return RdmaTransport::ExecuteServerHandshake(source, socket);
-    }
-#endif
-    return FallbackServerHandshake(source, socket);
-}
-
-}  // namespace rdma
-}  // namespace brpc
diff --git a/src/brpc/rdma_handshake_server.h b/src/brpc/rdma_handshake_server.h
deleted file mode 100644
index c4c5c91343..0000000000
--- a/src/brpc/rdma_handshake_server.h
+++ /dev/null
@@ -1,44 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#ifndef BRPC_RDMA_HANDSHAKE_SERVER_H
-#define BRPC_RDMA_HANDSHAKE_SERVER_H
-
-#include "brpc/parse_result.h"
-#include "brpc/transport_handshake.h"
-
-namespace butil {
-class IOBuf;
-}
-
-namespace brpc {
-class Socket;
-namespace rdma {
-
-using ServerHandshakeContext = handshake::ServerHandshakeContext;
-
-// The single server-side RDMA handshake entry for policy::ParseRdmaHandshake.
-// Returns a ParseResult ready to be handed back from the protocol parser:
-//   - not an RDMA magic / handshake finished -> PARSE_ERROR_TRY_OTHERS;
-//   - an RDMA magic but not enough bytes yet  -> PARSE_ERROR_NOT_ENOUGH_DATA;
-//   - IO/protocol error                       -> PARSE_ERROR_ABSOLUTELY_WRONG.
-ParseResult ExecuteServerHandshake(butil::IOBuf* source, Socket* socket);
-
-}  // namespace rdma
-}  // namespace brpc
-
-#endif  // BRPC_RDMA_HANDSHAKE_SERVER_H
diff --git a/src/brpc/rdma_transport.cpp b/src/brpc/rdma_transport.cpp
index 98e912113e..70cbbe40b0 100644
--- a/src/brpc/rdma_transport.cpp
+++ b/src/brpc/rdma_transport.cpp
@@ -20,11 +20,8 @@
 #include "brpc/rdma_transport.h"
 #include "brpc/adapter_transport.h"
 #include "brpc/event_dispatcher.h"
-#include "brpc/input_messenger.h"
+#include "brpc/handshake/rdma_handshake.h"
 #include "brpc/rdma/rdma_endpoint.h"
-#include "brpc/rdma_handshake.h"
-#include "brpc/rdma_handshake_constants.h"
-#include "brpc/rdma_handshake_server.h"
 #include "brpc/rdma/rdma_helper.h"
 
 namespace brpc {
@@ -169,84 +166,6 @@ void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
     return NULL;
 }
 
-ParseResult RdmaTransport::ExecuteServerHandshake(butil::IOBuf* source,
-                                                   Socket* socket) {
-    RdmaTransport* transport = RdmaTransport::Get(socket);
-    rdma::RdmaEndpoint* ep = transport->_rdma_ep;
-    CHECK(ep != NULL);
-
-    rdma::ParsedHello remote{};
-    std::vector<std::unique_ptr<rdma::RdmaHandshakeAdapter> > protocols =
-        rdma::CreateServerHandshakeAdapters(ep);
-    handshake::IOBufHandshakeInput input(source);
-    handshake::ServerHandshakeCallbacks callbacks{};
-    callbacks.phases = handshake::HandshakePhases{
-        S_ALLOC_QPCQ, S_HELLO_SEND, S_HELLO_WAIT,
-        S_BRINGUP_QP, 0, S_ACK_WAIT};
-    callbacks.fallback_on_not_mine = false;
-    callbacks.input = &input;
-    for (size_t i = 0; i < protocols.size(); ++i) {
-        handshake::HandshakeCodec codec = protocols[i]->MakeCodec(&remote);
-        const std::function<handshake::StepResult(const std::string&)>
-            parse_hello = codec.parse_hello;
-        codec.parse_hello = [transport, parse_hello](
-            const std::string& payload) {
-            const handshake::StepResult result = parse_hello(payload);
-            if (result == handshake::STEP_FALLBACK) {
-                transport->_rdma_state = RDMA_OFF;
-            }
-            return result;
-        };
-        callbacks.codecs.push_back(codec);
-    }
-    callbacks.prepare_resources = [&]() {
-        ep->ApplyRemoteInfo(remote);
-        if (ep->AllocateResources() < 0) {
-            PLOG(WARNING) << "Fail to allocate rdma resources, fallback to tcp:"
-                          << socket->description();
-            transport->_rdma_state = RDMA_OFF;
-            return handshake::STEP_FALLBACK;
-        }
-        return handshake::STEP_OK;
-    };
-    callbacks.negotiate_resources = [&]() {
-        if (ep->BringUpQp(remote, true) < 0) {
-            transport->_rdma_state = RDMA_OFF;
-            return handshake::STEP_FALLBACK;
-        }
-        return handshake::STEP_OK;
-    };
-    callbacks.validate_established = [&]() {
-        if (!source->empty() || transport->_rdma_state == RDMA_OFF) {
-            return handshake::STEP_ERROR;
-        }
-        return handshake::STEP_OK;
-    };
-    callbacks.set_high_speed_active = [transport]() {
-        transport->SetHighSpeedAvailable(true);
-    };
-    callbacks.set_tcp_active = [transport]() {
-        transport->SetHighSpeedAvailable(false);
-    };
-    callbacks.on_failed = []() {};
-
-    const handshake::StepResult result =
-        transport->handshake_session()->RunServer(callbacks);
-    if (result == handshake::STEP_NEED_MORE) {
-        if (transport->handshake_phase() == S_ACK_WAIT &&
-            socket->parsing_context() == NULL) {
-            socket->reset_parsing_context(
-                rdma::ServerHandshakeContext::Create());
-        }
-        return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
-    }
-    socket->reset_parsing_context(NULL);
-    if (result == handshake::STEP_ERROR) {
-        return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
-    }
-    return MakeParseError(PARSE_ERROR_TRY_OTHERS);
-}
-
 void RdmaTransport::Init(Socket *socket, const SocketOptions &options) {
     CHECK(_rdma_ep == NULL);
     _socket = socket;
diff --git a/src/brpc/rdma_transport.h b/src/brpc/rdma_transport.h
index 41a5155741..dcd6c1c45c 100644
--- a/src/brpc/rdma_transport.h
+++ b/src/brpc/rdma_transport.h
@@ -26,11 +26,15 @@
 
 namespace brpc {
 class AdapterTransport;
+namespace handshake {
+class RdmaServerHandshakeAdapter;
+}
 class RdmaTransport : public Transport {
     friend class TransportFactory;
     friend class AdapterTransport;
     friend class rdma::RdmaEndpoint;
     friend class rdma::RdmaConnect;
+    friend class handshake::RdmaServerHandshakeAdapter;
 public:
     enum HandshakeState {
         UNINIT = 0x0,
@@ -75,8 +79,6 @@ class RdmaTransport : public Transport {
     // TCP control-plane callbacks. The endpoint is intentionally absent from
     // these entry points and only participates through resource operations.
     static void* ProcessHandshakeAtClient(void* arg);
-    static ParseResult ExecuteServerHandshake(butil::IOBuf* source,
-                                              Socket* socket);
 private:
     AdapterTransport* adapter_transport() const;
     handshake::HandshakeSession* handshake_session() const;
diff --git a/test/brpc_rdma_unittest.cpp b/test/brpc_rdma_unittest.cpp
index 7e0ce9a427..bc09756675 100644
--- a/test/brpc_rdma_unittest.cpp
+++ b/test/brpc_rdma_unittest.cpp
@@ -38,8 +38,8 @@
 #include "brpc/rdma_transport.h"
 #include "brpc/rdma/block_pool.h"
 #include "brpc/rdma/rdma_endpoint.h"
-#include "brpc/rdma_handshake.h"
-#include "brpc/rdma_handshake_constants.h"
+#include "brpc/handshake/rdma_handshake.h"
+#include "brpc/handshake/rdma_handshake_constants.h"
 #include "brpc/rdma_handshake.pb.h"
 #include "brpc/rdma/rdma_helper.h"
 #include "echo.pb.h"
@@ -57,7 +57,7 @@ DEFINE_bool(rdma_test_enable, false, "Enable tests requring rdma runtime.");
 namespace rdma {
 
 // HELLO_V2_VERSION / IMPL_V2_VERSION come from
-// brpc/rdma_handshake_constants.h (shared wire constants).
+// brpc/handshake/rdma_handshake_constants.h (shared wire constants).
 
 DECLARE_bool(rdma_trace_verbose);
 DECLARE_int32(rdma_memory_pool_max_regions);

From 42949c39a5fd7385afbc9c0885cfa220da6ee912 Mon Sep 17 00:00:00 2001
From: Gzure <740684863@qq.com>
Date: Wed, 19 Aug 2026 16:54:42 +0800
Subject: [PATCH 09/11] Move UBSHM handshake into common adapter

---
 docs/cn/handshake_common_design.md            |  34 +-
 src/brpc/adapter_transport.cpp                |  34 +-
 src/brpc/adapter_transport.h                  |   1 -
 src/brpc/global.cpp                           |  14 +-
 src/brpc/handshake/handshake_adapter.cpp      |  12 +-
 src/brpc/handshake/rdma_handshake.h           |   6 +-
 src/brpc/handshake/ubshm_handshake.cpp        | 430 ++++++++++++++++++
 src/brpc/handshake/ubshm_handshake.h          |  84 ++++
 src/brpc/policy/rdma_handshake_protocol.cpp   |  15 +-
 src/brpc/policy/rdma_handshake_protocol.h     |  27 +-
 .../policy/transport_handshake_protocol.cpp   |  53 +++
 .../policy/transport_handshake_protocol.h     |  44 ++
 src/brpc/transport_handshake.cpp              |  11 +-
 src/brpc/transport_handshake.h                |  14 +-
 src/brpc/ubshm/ub_endpoint.cpp                | 380 ----------------
 src/brpc/ubshm/ub_endpoint.h                  |  22 +-
 src/brpc/ubshm_transport.cpp                  | 137 +++++-
 src/brpc/ubshm_transport.h                    |   7 +-
 test/brpc_rdma_unittest.cpp                   |  11 +-
 test/brpc_transport_handshake_unittest.cpp    | 126 +++++
 test/brpc_ubring_unittest.cpp                 |  40 ++
 21 files changed, 1005 insertions(+), 497 deletions(-)
 create mode 100644 src/brpc/handshake/ubshm_handshake.cpp
 create mode 100644 src/brpc/handshake/ubshm_handshake.h
 create mode 100644 src/brpc/policy/transport_handshake_protocol.cpp
 create mode 100644 src/brpc/policy/transport_handshake_protocol.h

diff --git a/docs/cn/handshake_common_design.md b/docs/cn/handshake_common_design.md
index 0b3869e2ab..46501c8a09 100644
--- a/docs/cn/handshake_common_design.md
+++ b/docs/cn/handshake_common_design.md
@@ -19,7 +19,7 @@ TCP 连接建立
     -> 成功切换高速通道，或回退到 TCP
 ```
 
-目前公共流程主要以复制代码的形式存在。例如：
+重构前公共流程主要以复制代码的形式存在。例如：
 
 - RDMA 的 TCP 握手读写循环在 `rdma_endpoint.cpp` 中实现；
 - URMA 在 `urma_endpoint.cpp` 中重新实现了一套；
@@ -83,10 +83,9 @@ Hello 中携带：
 
 相关代码：
 
-- `src/brpc/ubshm/ub_endpoint.h`
-- `src/brpc/ubshm/ub_endpoint.cpp:63`
-- `src/brpc/ubshm/ub_endpoint.cpp:331`
-- `src/brpc/ubshm/ub_endpoint.cpp:460`
+- `src/brpc/handshake/ubshm_handshake.*`
+- `src/brpc/ubshm_transport.*`
+- `src/brpc/ubshm/ub_endpoint.*`
 
 ## 3. 设计目标
 
@@ -124,6 +123,8 @@ src/brpc/
     handshake/handshake_io.*     # blocking fd I/O 与增量 IOBuf 输入适配
     handshake/handshake_frame.*  # fixed/U16/U32 通用 framing
     handshake/rdma_handshake.*   # RDMA v2/v3 字段与 server handshake adapter
+    handshake/ubshm_handshake.*  # UBSHM v2 字段与 server handshake adapter
+    policy/transport_handshake_protocol.* # RDMA/UBSHM server magic 分发
     rdma_handshake.proto         # RDMA v3 wire message
     rdma_transport.h/.cpp        # 独立 RDMA Transport、握手回调与数据面
     ubshm_transport.h/.cpp       # 独立 UBSHM Transport、握手回调与数据面
@@ -142,6 +143,7 @@ flowchart TB
     UT --> UTRA["UrmaTransport"]
     UT --> BT["UBShmTransport"]
     RT --> RA["RDMA handshake adapter"]
+    BT --> BA["UBSHM handshake adapter"]
     RT --> RE["RdmaEndpoint\nQP / CQ / MR"]
     UTRA --> UE["UrmaEndpoint\nJetty / JFC / Segment"]
     BT --> BE["UBShmEndpoint\nUBRing / Shared Memory"]
@@ -317,7 +319,7 @@ public:
 
 - client：通过 `SocketHandshakeIO` 统一执行 blocking fd 读写；
 - server：把 `butil::IOBuf` 封装成 `IOBufHandshakeInput`；
-- UBSHM 当前 server 也使用 fd 读取，可先使用 `SocketHandshakeIO`，后续再迁移到增量解析；
+- UBSHM server 与 RDMA 一样使用 `IOBufHandshakeInput`，由 bRPC 标准协议解析流程增量驱动；
 - RDMA 的 `RdmaServerHandshakeAdapter` 直接使用 `HandshakeInput`。
 
 ### 5.3 FrameCodec
@@ -454,8 +456,8 @@ UNINIT
 
 server 解析必须保留 `NEED_MORE_DATA`：
 
-- RDMA 的 policy parser 可能多次收到 `IOBuf` 片段；
-- 后续 URMA/UBSHM 如果接入统一 server parser，也需要同样行为；
+- RDMA/UBSHM 的公共 transport-handshake policy parser 可能多次收到 `IOBuf` 片段；
+- 后续 URMA 接入统一 server parser 时也需要同样行为；
 - 未读完整时不得消费输入缓冲区。
 
 ### 6.3 公共驱动与具体资源实现的边界
@@ -515,7 +517,7 @@ BuildAck   -> URMA ACK
 
 - `HelloMessage`；
 - `HelloMessage::Serialize/Deserialize`；
-- `HelloNegotiationValid`；
+- hello/implementation version 校验；
 - shared memory 名称和长度校验；
 - `AllocateClientResources/AllocateServerResources`；
 - `UB_OK` ACK bit。
@@ -686,7 +688,7 @@ Hello valid
 
 ### Phase 3：清理旧实现
 
-- **已完成（RDMA/UBSHM）**：删除重复的握手 fd 读写，统一使用 `SocketHandshakeIO`；
+- **已完成（RDMA/UBSHM）**：删除 Endpoint 中重复的握手 fd 读写；client 统一使用 `SocketHandshakeIO`，server 统一使用 `IOBufHandshakeInput`；
 - **已完成（RDMA/UBSHM）**：删除可替代的 magic/length 解析，统一使用 `FrameCodec`；
 - **已完成**：仅保留各协议的 payload 字段 codec 和资源回调；
 - **已完成**：CMake/Bazel 通过递归 glob 收录，Makefile 增加 `src/brpc/handshake`，并更新公共测试；
@@ -758,6 +760,8 @@ classDiagram
     class StandardHandshakeAdapter
     class RdmaServerHandshakeAdapter
     class RdmaHandshakeAdapter
+    class UBShmServerHandshakeAdapter
+    class UBShmHandshakeAdapter
     class HandshakeCodec
     class FrameCodec
     class UrmaTransport
@@ -779,16 +783,20 @@ classDiagram
     HandshakeSession o-- HandshakeCodec
     HandshakeAdapter <|-- StandardHandshakeAdapter
     StandardHandshakeAdapter <|-- RdmaServerHandshakeAdapter
+    StandardHandshakeAdapter <|-- UBShmServerHandshakeAdapter
     RdmaServerHandshakeAdapter --> HandshakeSession
     RdmaServerHandshakeAdapter --> RdmaHandshakeAdapter
+    UBShmServerHandshakeAdapter --> HandshakeSession
+    UBShmServerHandshakeAdapter --> UBShmHandshakeAdapter
     RdmaTransport --> RdmaHandshakeAdapter
+    UBShmTransport --> UBShmHandshakeAdapter
     RdmaTransport --> HighSpeedEndpoint
     UBShmTransport --> HighSpeedEndpoint
 ```
 
 `AdapterTransport` 是安装在 `Socket` 上的最上层 TCP-first Transport：`UNINITIALIZED/NEGOTIATING/FALLBACK_TCP` 都委托给 `TcpTransport`，仅当 `HandshakeSession` release 发布 `ESTABLISHED` 后才委托给所选的 RDMA/URMA/UBSHM Transport。成功升级后的 TCP 控制连接只允许 EOF，不再接受应用数据。
 
-`HandshakeSession::RunClient/RunServer` 持有 `HandshakeCodec` 并统一执行 framing、Hello/ACK 收发、字段 codec 调用、资源准备/协商回调以及 established/fallback/failed 发布。`StandardHandshakeAdapter::ExecuteServerHandshake` 统一桥接 bRPC 标准 parser；`RdmaServerHandshakeAdapter` 组装 RDMA 或 plain-TCP fallback callback。RDMA/UBSHM callback 只解析协议字段或执行具体资源动作；RDMA server 的 `STEP_NEED_MORE` 仍由标准 parser 增量驱动，UBSHM server 使用同一 Session driver 的 blocking 模式。
+`HandshakeSession::RunClient/RunServer` 持有 `HandshakeCodec` 并统一执行 framing、Hello/ACK 收发、字段 codec 调用、资源准备/协商回调以及 established/fallback/failed 发布。`StandardHandshakeAdapter::ExecuteServerHandshake` 统一桥接 bRPC 标准 parser；`RdmaServerHandshakeAdapter` 和 `UBShmServerHandshakeAdapter` 分别组装真实高速连接或 plain-TCP fallback callback。公共 `transport_handshake` policy 根据 magic 分发首次 Hello，并在 parsing context 中保留选中的 adapter，确保后续无 magic 的 ACK 仍回到同一状态机。注册时暂时保留既有 `PROTOCOL_RDMA_HANDSHAKE` 数值和 `rdma_handshake` 名称，避免破坏兼容性。RDMA/UBSHM server 都由标准 parser 增量驱动。
 
 ### 14.1 当前完成度
 
@@ -797,10 +805,10 @@ classDiagram
 | TCP-first 路由 | 已实现 | `Socket` 持有顶层 `AdapterTransport`；其组合 `TcpTransport` 和一个独立高速 `Transport` |
 | 公共握手处理 | 已实现 | `RunClient/RunServer` 统一 FrameCodec、字段 codec、资源回调、ACK、fallback 和错误流程 |
 | RDMA client/server | 已迁移 | adapter、wire 常量和 server executor 位于 `src/brpc/handshake`；真实 RDMA 与无 RDMA Endpoint 的 fallback 共用 `HandshakeAdapter/Session`；server 保留 #3350 的标准增量解析流程 |
-| UBSHM client/server | 已迁移 | 固定 64 字节 framing、2 字节 magic、ACK 和 fd I/O 已进入公共组件；server 当前仍使用 blocking 输入 |
+| UBSHM client/server | 已迁移 | 字段 codec、固定 64 字节 framing、2 字节 magic、ACK 与 server executor 位于 `src/brpc/handshake`；client 由 `UBShmTransport` 驱动，server 与 RDMA 一样走标准增量 parser |
 | URMA | 待迁移 | origin/master 暂无受版本控制的 URMA Transport；合入后保留独立 `UrmaTransport`，由顶层 `AdapterTransport` 组合并复用 `HandshakeSession` |
 | RDMA Protocol adapter | 已实现 | `RdmaHandshakeAdapter` 只构造/解析 v2/v3 payload 字段，不再读写 fd 或消费 `IOBuf` |
-| Server parser adapter | 已实现 | `HandshakeAdapter` 抽象唯一入口；`StandardHandshakeAdapter` 统一 ParseResult、ACK_WAIT context 和清理流程；协议只实现 driver hook |
+| Server parser adapter | 已实现 | `HandshakeAdapter` 抽象唯一入口；`StandardHandshakeAdapter` 统一 ParseResult、ACK_WAIT context 和清理流程；公共 policy 分发 RDMA/UBSHM，协议只实现 driver hook |
 | 通用 FrameCodec | 已实现 | 支持 fixed、U16 总长度、U32 body 长度、2/4 字节 magic、blocking I/O 和增量 `IOBuf` 解析 |
 
 ### 14.2 必须继承的修复语义
diff --git a/src/brpc/adapter_transport.cpp b/src/brpc/adapter_transport.cpp
index e952b0c9de..bc06df70e4 100644
--- a/src/brpc/adapter_transport.cpp
+++ b/src/brpc/adapter_transport.cpp
@@ -54,6 +54,13 @@ void AdapterTransport::Init(Socket* socket, const SocketOptions& options) {
                        get_client_side_messenger())) {
             // RDMA server handshake is parsed by InputMessenger.
             _on_edge_trigger = InputMessenger::OnNewMessages;
+#endif
+#if BRPC_WITH_UBRING
+        } else if (_mode == SOCKET_MODE_UBRING &&
+                   options.user != static_cast<SocketUser*>(
+                       get_client_side_messenger())) {
+            // UBSHM server handshake is parsed by InputMessenger.
+            _on_edge_trigger = InputMessenger::OnNewMessages;
 #endif
         } else {
             _on_edge_trigger = OnNewDataFromTcp;
@@ -173,23 +180,6 @@ void AdapterTransport::SetHighSpeedAvailable(bool available) {
     }
 }
 
-void AdapterTransport::StartServerHandshake() {
-    if (!_high_speed_transport) {
-        return;
-    }
-    switch (_mode) {
-#if BRPC_WITH_UBRING
-    case SOCKET_MODE_UBRING:
-        static_cast<UBShmTransport*>(_high_speed_transport.get())
-            ->StartServerHandshake();
-        break;
-#endif
-    default:
-        // RDMA uses the standard InputMessenger protocol parser.
-        break;
-    }
-}
-
 void AdapterTransport::OnNewDataFromTcp(Socket* socket) {
     static_cast<AdapterTransport*>(socket->_transport.get())->ProcessTcpEvent();
 }
@@ -198,14 +188,8 @@ void AdapterTransport::ProcessTcpEvent() {
     int progress = Socket::PROGRESS_INIT;
     while (true) {
         const int phase = _handshake.phase();
-        if (phase == handshake::UNINITIALIZED) {
-            if (!_socket->CreatedByConnect() && _high_speed_transport) {
-                StartServerHandshake();
-                if (_handshake.phase() != handshake::UNINITIALIZED) {
-                    continue;
-                }
-            }
-        } else if (phase < handshake::ESTABLISHED) {
+        if (phase != handshake::UNINITIALIZED &&
+            phase < handshake::ESTABLISHED) {
             _handshake.NotifyReadable();
         } else if (phase == handshake::FALLBACK_TCP) {
             InputMessenger::OnNewMessages(_socket);
diff --git a/src/brpc/adapter_transport.h b/src/brpc/adapter_transport.h
index 487b5ab548..a56c8e96e9 100644
--- a/src/brpc/adapter_transport.h
+++ b/src/brpc/adapter_transport.h
@@ -69,7 +69,6 @@ class AdapterTransport : public Transport {
 
     Transport* ActiveTransport() const;
     void SetHighSpeedAvailable(bool available);
-    void StartServerHandshake();
     void FallbackToTcp();
     void TryReadOnTcp();
     void ProcessTcpEvent();
diff --git a/src/brpc/global.cpp b/src/brpc/global.cpp
index 04a56282ea..319ffaba64 100644
--- a/src/brpc/global.cpp
+++ b/src/brpc/global.cpp
@@ -69,7 +69,7 @@
 
 // Protocols
 #include "brpc/protocol.h"
-#include "brpc/policy/rdma_handshake_protocol.h"
+#include "brpc/policy/transport_handshake_protocol.h"
 #include "brpc/policy/baidu_rpc_protocol.h"
 #include "brpc/policy/http_rpc_protocol.h"
 #include "brpc/policy/http2_rpc_protocol.h"
@@ -438,12 +438,16 @@ static void GlobalInitializeOrDieImpl() {
     }
 
     // Protocols
-    Protocol rdma_handshake_protocol = {
-        ParseRdmaHandshake, NULL, NULL,
-        ProcessRdmaHandshake, NULL,
+    Protocol transport_handshake_protocol = {
+        ParseTransportHandshake, NULL, NULL,
+        ProcessTransportHandshake, NULL,
         NULL, NULL, NULL,
         CONNECTION_TYPE_ALL, "rdma_handshake" };
-    if (RegisterProtocol(PROTOCOL_RDMA_HANDSHAKE, rdma_handshake_protocol) != 0) {
+    // Retain the existing enum value and registered name to avoid changing
+    // public protocol identifiers while widening the implementation from RDMA
+    // to all transport upgrades.
+    if (RegisterProtocol(PROTOCOL_RDMA_HANDSHAKE,
+                         transport_handshake_protocol) != 0) {
         exit(1);
     }
 
diff --git a/src/brpc/handshake/handshake_adapter.cpp b/src/brpc/handshake/handshake_adapter.cpp
index 501b71cc45..8c0f1153c4 100644
--- a/src/brpc/handshake/handshake_adapter.cpp
+++ b/src/brpc/handshake/handshake_adapter.cpp
@@ -25,15 +25,21 @@ namespace handshake {
 // InputMessenger may call this entry repeatedly while bytes arrive. Keep all
 // connection state in HandshakeSession and Socket rather than in the adapter,
 // so a single stateless adapter can serve every connection. The parsing
-// context is only a marker that keeps InputMessenger on the selected protocol
-// between the server hello and the peer ACK.
+// context retains that selected adapter between the server hello and the peer
+// ACK, whose frame has no protocol magic of its own.
 ParseResult StandardHandshakeAdapter::ExecuteServerHandshake(
     butil::IOBuf* source, Socket* socket) {
     const StepResult result = RunServerHandshake(source, socket);
     if (result == STEP_NEED_MORE) {
         if (GetSession(socket)->phase() == AckWaitPhase(socket) &&
             socket->parsing_context() == NULL) {
-            socket->reset_parsing_context(ServerHandshakeContext::Create());
+            ServerHandshakeContext* context =
+                ServerHandshakeContext::Create(this);
+            if (context == NULL) {
+                GetSession(socket)->MarkFailed();
+                return MakeParseError(PARSE_ERROR_ABSOLUTELY_WRONG);
+            }
+            socket->reset_parsing_context(context);
         }
         return MakeParseError(PARSE_ERROR_NOT_ENOUGH_DATA);
     }
diff --git a/src/brpc/handshake/rdma_handshake.h b/src/brpc/handshake/rdma_handshake.h
index 71e9067820..7552454c34 100644
--- a/src/brpc/handshake/rdma_handshake.h
+++ b/src/brpc/handshake/rdma_handshake.h
@@ -23,9 +23,9 @@
 namespace brpc {
 namespace handshake {
 
-// Returns the single adapter used by policy::ParseRdmaHandshake. The concrete
-// RDMA type is private to the implementation; callers only learn the common
-// HandshakeAdapter interface.
+// Returns the RDMA adapter used by policy::ParseTransportHandshake. The
+// concrete type is private to the implementation; callers only learn the
+// common HandshakeAdapter interface.
 HandshakeAdapter* GetRdmaServerHandshakeAdapter();
 
 }  // namespace handshake
diff --git a/src/brpc/handshake/ubshm_handshake.cpp b/src/brpc/handshake/ubshm_handshake.cpp
new file mode 100644
index 0000000000..328a7b5ccb
--- /dev/null
+++ b/src/brpc/handshake/ubshm_handshake.cpp
@@ -0,0 +1,430 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "brpc/handshake/ubshm_handshake.h"
+
+#include <errno.h>
+#include <cstdio>
+
+#include "butil/raw_pack.h"
+#include "butil/sys_byteorder.h"
+#include "brpc/adapter_transport.h"
+#include "brpc/socket.h"
+
+#if BRPC_WITH_UBRING
+
+#include <array>
+#include <cstring>
+
+#include "butil/logging.h"
+#include "brpc/reloadable_flags.h"
+#include "brpc/ubshm/common/common.h"
+#include "brpc/ubshm/ub_endpoint.h"
+#include "brpc/ubshm/ub_helper.h"
+#include "brpc/ubshm/ubr_trx.h"
+#include "brpc/ubshm_transport.h"
+
+#endif
+
+namespace brpc {
+namespace handshake {
+namespace ubshm_wire {
+
+static const char* const MAGIC = "UB";
+static const size_t MAGIC_LEN = 2;
+static const size_t HELLO_LEN = 64;
+static const size_t ACK_LEN = 4;
+static const uint16_t HELLO_VERSION = 2;
+static const uint16_t IMPL_VERSION = 1;
+static const uint32_t ACK_OK = 0x1;
+
+static const FrameSpec& HelloFrameSpec() {
+    static const FrameSpec spec(
+        MAGIC, MAGIC_LEN, HELLO_LEN, HELLO_LEN, FrameSpec::FIXED);
+    return spec;
+}
+
+static const FrameSpec& AckFrameSpec() {
+    static const FrameSpec spec(
+        NULL, 0, ACK_LEN, ACK_LEN, FrameSpec::FIXED);
+    return spec;
+}
+
+}  // namespace ubshm_wire
+}  // namespace handshake
+}  // namespace brpc
+
+#if BRPC_WITH_UBRING
+
+namespace brpc {
+namespace ubring {
+
+DEFINE_int32(data_queue_size, 4, "data queue size for UB");
+DEFINE_bool(ub_trace_verbose, false, "Print log message verbosely");
+BRPC_VALIDATE_GFLAG(ub_trace_verbose, brpc::PassValidate);
+
+void HelloMessage::Serialize(void* data) const {
+    char* current_pos = static_cast<char*>(data);
+    const uint16_t net_msg_len = butil::HostToNet16(msg_len);
+    memcpy(current_pos, &net_msg_len, sizeof(net_msg_len));
+    current_pos += sizeof(net_msg_len);
+    const uint16_t net_hello_ver = butil::HostToNet16(hello_ver);
+    memcpy(current_pos, &net_hello_ver, sizeof(net_hello_ver));
+    current_pos += sizeof(net_hello_ver);
+    const uint16_t net_impl_ver = butil::HostToNet16(impl_ver);
+    memcpy(current_pos, &net_impl_ver, sizeof(net_impl_ver));
+    current_pos += sizeof(net_impl_ver);
+    const uint64_t net_len = butil::HostToNet64(len);
+    memcpy(current_pos, &net_len, sizeof(net_len));
+    current_pos += sizeof(net_len);
+    memcpy(current_pos, shm_name, SHM_MAX_NAME_BUFF_LEN);
+}
+
+void HelloMessage::Deserialize(const void* data) {
+    const char* current_pos = static_cast<const char*>(data);
+    uint16_t net_msg_len;
+    memcpy(&net_msg_len, current_pos, sizeof(net_msg_len));
+    msg_len = butil::NetToHost16(net_msg_len);
+    current_pos += sizeof(net_msg_len);
+    uint16_t net_hello_ver;
+    memcpy(&net_hello_ver, current_pos, sizeof(net_hello_ver));
+    hello_ver = butil::NetToHost16(net_hello_ver);
+    current_pos += sizeof(net_hello_ver);
+    uint16_t net_impl_ver;
+    memcpy(&net_impl_ver, current_pos, sizeof(net_impl_ver));
+    impl_ver = butil::NetToHost16(net_impl_ver);
+    current_pos += sizeof(net_impl_ver);
+    uint64_t net_len;
+    memcpy(&net_len, current_pos, sizeof(net_len));
+    len = butil::NetToHost64(net_len);
+    current_pos += sizeof(net_len);
+    memcpy(shm_name, current_pos, SHM_MAX_NAME_BUFF_LEN);
+}
+
+std::string HelloMessage::toString() const {
+    constexpr size_t MAX_LEN =
+        16 + 6 + 16 + 6 + 16 + 6 + 20 + 6 + SHM_MAX_NAME_BUFF_LEN + 32;
+    std::array<char, MAX_LEN> buf;
+    const int n = snprintf(
+        buf.data(), buf.size(),
+        "msg_len=%u, hello_ver=%u, impl_ver=%u, len=%lu, shm_name=%.*s",
+        msg_len, hello_ver, impl_ver,
+        static_cast<unsigned long>(len),
+        static_cast<int>(SHM_MAX_NAME_BUFF_LEN), shm_name);
+    return std::string(buf.data(), static_cast<size_t>(n));
+}
+
+handshake::HandshakeCodec UBShmHandshakeAdapter::MakeCodec() const {
+    handshake::HandshakeCodec codec{};
+    codec.protocol_version = 2;
+    codec.hello_frame = handshake::ubshm_wire::HelloFrameSpec();
+    codec.ack_frame = handshake::ubshm_wire::AckFrameSpec();
+    codec.build_ack = [](bool enabled, std::string* payload) {
+        const uint32_t flags_be = butil::HostToNet32(
+            enabled ? handshake::ubshm_wire::ACK_OK : 0);
+        payload->assign(reinterpret_cast<const char*>(&flags_be),
+                        sizeof(flags_be));
+        return handshake::STEP_OK;
+    };
+    codec.parse_ack = [](const std::string& payload, bool* enabled) {
+        if (payload.size() != handshake::ubshm_wire::ACK_LEN) {
+            errno = EPROTO;
+            return handshake::STEP_ERROR;
+        }
+        uint32_t flags_be = 0;
+        memcpy(&flags_be, payload.data(), sizeof(flags_be));
+        *enabled = (butil::NetToHost32(flags_be) &
+                    handshake::ubshm_wire::ACK_OK) != 0;
+        return handshake::STEP_OK;
+    };
+    return codec;
+}
+
+handshake::StepResult UBShmHandshakeAdapter::BuildHello(
+    bool enabled, uint64_t len, const char* shm_name,
+    std::string* payload) const {
+    HelloMessage message{};
+    message.msg_len = static_cast<uint16_t>(
+        handshake::ubshm_wire::HELLO_LEN);
+    if (enabled) {
+        message.hello_ver = handshake::ubshm_wire::HELLO_VERSION;
+        message.impl_ver = handshake::ubshm_wire::IMPL_VERSION;
+        message.len = len;
+        memcpy(message.shm_name, shm_name, SHM_MAX_NAME_BUFF_LEN);
+    }
+    payload->assign(
+        handshake::ubshm_wire::HELLO_LEN -
+            handshake::ubshm_wire::MAGIC_LEN,
+        '\0');
+    message.Serialize(&(*payload)[0]);
+    return handshake::STEP_OK;
+}
+
+handshake::StepResult UBShmHandshakeAdapter::ParseHello(
+    const std::string& payload, HelloMessage* message) const {
+    if (payload.size() != handshake::ubshm_wire::HELLO_LEN -
+                              handshake::ubshm_wire::MAGIC_LEN) {
+        errno = EPROTO;
+        return handshake::STEP_ERROR;
+    }
+    message->Deserialize(payload.data());
+    if (message->msg_len < handshake::ubshm_wire::HELLO_LEN) {
+        errno = EPROTO;
+        return handshake::STEP_ERROR;
+    }
+    return NegotiationValid(*message) ?
+        handshake::STEP_OK : handshake::STEP_FALLBACK;
+}
+
+bool UBShmHandshakeAdapter::NegotiationValid(
+    const HelloMessage& message) const {
+    return message.hello_ver == handshake::ubshm_wire::HELLO_VERSION &&
+           message.impl_ver == handshake::ubshm_wire::IMPL_VERSION;
+}
+
+}  // namespace ubring
+}  // namespace brpc
+
+#endif  // BRPC_WITH_UBRING
+
+namespace brpc {
+namespace handshake {
+
+class UBShmServerHandshakeAdapter : public StandardHandshakeAdapter {
+public:
+    UBShmServerHandshakeAdapter() = default;
+
+protected:
+    StepResult RunServerHandshake(
+        butil::IOBuf* source, Socket* socket) override;
+    HandshakeSession* GetSession(Socket* socket) const override;
+    int AckWaitPhase(const Socket* socket) const override;
+
+private:
+    StepResult RunFallbackServerHandshake(
+        butil::IOBuf* source, Socket* socket);
+#if BRPC_WITH_UBRING
+    StepResult RunUBShmServerHandshake(
+        butil::IOBuf* source, Socket* socket);
+#endif
+
+    DISALLOW_COPY_AND_ASSIGN(UBShmServerHandshakeAdapter);
+};
+
+static const int FALLBACK_PREPARE = 1;
+static const int FALLBACK_HELLO_SEND = 2;
+static const int FALLBACK_HELLO_WAIT = 3;
+static const int FALLBACK_NEGOTIATE = 4;
+static const int FALLBACK_ACK_SEND = 5;
+static const int FALLBACK_ACK_WAIT = 6;
+
+static HandshakeCodec MakeUBShmFallbackCodec() {
+    HandshakeCodec codec{};
+    codec.protocol_version = 2;
+    codec.hello_frame = ubshm_wire::HelloFrameSpec();
+    codec.ack_frame = ubshm_wire::AckFrameSpec();
+    codec.parse_hello = [](const std::string&) {
+        return STEP_FALLBACK;
+    };
+    codec.build_hello = [](bool enabled, std::string* payload) {
+        if (enabled) {
+            errno = EPROTO;
+            return STEP_ERROR;
+        }
+        payload->assign(
+            ubshm_wire::HELLO_LEN - ubshm_wire::MAGIC_LEN, '\0');
+        butil::RawPacker(&(*payload)[0])
+            .pack16(static_cast<uint16_t>(ubshm_wire::HELLO_LEN));
+        return STEP_OK;
+    };
+    codec.build_ack = [](bool enabled, std::string* payload) {
+        const uint32_t flags_be = butil::HostToNet32(
+            enabled ? ubshm_wire::ACK_OK : 0);
+        payload->assign(reinterpret_cast<const char*>(&flags_be),
+                        sizeof(flags_be));
+        return STEP_OK;
+    };
+    codec.parse_ack = [](const std::string& payload, bool* enabled) {
+        if (payload.size() != ubshm_wire::ACK_LEN) {
+            errno = EPROTO;
+            return STEP_ERROR;
+        }
+        *enabled = false;
+        return STEP_OK;
+    };
+    return codec;
+}
+
+HandshakeAdapter* GetUBShmServerHandshakeAdapter() {
+    static UBShmServerHandshakeAdapter adapter;
+    return &adapter;
+}
+
+HandshakeSession* UBShmServerHandshakeAdapter::GetSession(
+    Socket* socket) const {
+    return AdapterTransport::Get(socket)->handshake_session();
+}
+
+int UBShmServerHandshakeAdapter::AckWaitPhase(
+    const Socket* socket) const {
+#if BRPC_WITH_UBRING
+    if (socket->socket_mode() == SOCKET_MODE_UBRING) {
+        return UBShmTransport::S_ACK_WAIT;
+    }
+#endif
+    return FALLBACK_ACK_WAIT;
+}
+
+StepResult UBShmServerHandshakeAdapter::RunFallbackServerHandshake(
+    butil::IOBuf* source, Socket* socket) {
+    IOBufHandshakeInput input(source);
+    ServerHandshakeCallbacks callbacks{};
+    callbacks.phases = HandshakePhases{
+        FALLBACK_PREPARE, FALLBACK_HELLO_SEND, FALLBACK_HELLO_WAIT,
+        FALLBACK_NEGOTIATE, FALLBACK_ACK_SEND, FALLBACK_ACK_WAIT};
+    callbacks.fallback_on_not_mine = false;
+    callbacks.codecs.push_back(MakeUBShmFallbackCodec());
+    callbacks.input = &input;
+    callbacks.prepare_resources = []() { return STEP_OK; };
+    callbacks.negotiate_resources = []() { return STEP_OK; };
+    callbacks.set_high_speed_active = []() {};
+    callbacks.set_tcp_active = []() {};
+    callbacks.on_failed = []() {};
+    return GetSession(socket)->RunServer(callbacks);
+}
+
+#if BRPC_WITH_UBRING
+StepResult UBShmServerHandshakeAdapter::RunUBShmServerHandshake(
+    butil::IOBuf* source, Socket* socket) {
+    UBShmTransport* transport = UBShmTransport::Get(socket);
+    ubring::UBShmEndpoint* ep = transport->_ub_ep;
+    CHECK(ep != NULL);
+
+    ubring::HelloMessage remote{};
+    ubring::UBShmHandshakeAdapter wire;
+    IOBufHandshakeInput input(source);
+    ServerHandshakeCallbacks callbacks{};
+    callbacks.phases = HandshakePhases{
+        UBShmTransport::S_ALLOC_SHM, UBShmTransport::S_HELLO_SEND,
+        UBShmTransport::S_HELLO_WAIT, UBShmTransport::S_ALLOC_SHM,
+        0, UBShmTransport::S_ACK_WAIT};
+    callbacks.fallback_on_not_mine = false;
+    callbacks.input = &input;
+    HandshakeCodec codec = wire.MakeCodec();
+    codec.parse_hello = [&](const std::string& payload) {
+        const StepResult result = wire.ParseHello(payload, &remote);
+        if (result == STEP_OK || result == STEP_FALLBACK) {
+            LOG_IF(INFO, ubring::FLAGS_ub_trace_verbose)
+                << "server receive handshake message : "
+                << remote.toString();
+        }
+        if (result == STEP_FALLBACK) {
+            transport->_ub_state = UBShmTransport::UB_OFF;
+        }
+        return result;
+    };
+    codec.build_hello = [&](bool enabled, std::string* payload) {
+        const uint64_t len = enabled
+            ? static_cast<uint64_t>(ubring::FLAGS_data_queue_size) *
+                  MB_TO_BYTE
+            : 0;
+        return wire.BuildHello(
+            enabled, len, enabled ? remote.shm_name : NULL, payload);
+    };
+    callbacks.codecs.push_back(codec);
+    callbacks.prepare_resources = [&]() {
+        if (!ubring::IsUBAvailable()) {
+            transport->_ub_state = UBShmTransport::UB_OFF;
+            return STEP_FALLBACK;
+        }
+        ubring::SHM remote_trx_shm = {
+            NULL, remote.len, 0, {0},
+            static_cast<uint32_t>(socket->fd())};
+        strncpy(remote_trx_shm.name, remote.shm_name,
+                SHM_MAX_NAME_BUFF_LEN);
+
+        const size_t local_shm_len =
+            static_cast<size_t>(ubring::FLAGS_data_queue_size) * MB_TO_BYTE;
+        ubring::SHM local_trx_shm = {
+            NULL, local_shm_len, 0, {0},
+            static_cast<uint32_t>(socket->fd())};
+        char client_name[SHM_MAX_NAME_BUFF_LEN + 1];
+        memcpy(client_name, remote.shm_name, SHM_MAX_NAME_BUFF_LEN);
+        client_name[SHM_MAX_NAME_BUFF_LEN] = '\0';
+        char* client_ip_port = strrchr(client_name, '_');
+        if (client_ip_port != NULL) {
+            *client_ip_port = '\0';
+        }
+        const int result = snprintf(
+            local_trx_shm.name, SHM_MAX_NAME_BUFF_LEN, "%s_%s",
+            client_name, SERVER_SHM_NAME_SUFFIX);
+        if (UNLIKELY(result < 0)) {
+            transport->_ub_state = UBShmTransport::UB_OFF;
+            return STEP_FALLBACK;
+        }
+        if (ep->AllocateServerResources(
+                &remote_trx_shm, &local_trx_shm) < 0) {
+            LOG(WARNING)
+                << "Fail to allocate ub resources, fallback to tcp:"
+                << socket->description();
+            transport->_ub_state = UBShmTransport::UB_OFF;
+            return STEP_FALLBACK;
+        }
+        return STEP_OK;
+    };
+    callbacks.negotiate_resources = []() { return STEP_OK; };
+    callbacks.validate_established = [&]() {
+        if (!source->empty() ||
+            transport->_ub_state == UBShmTransport::UB_OFF) {
+            return STEP_ERROR;
+        }
+        return STEP_OK;
+    };
+    callbacks.set_high_speed_active = [transport]() {
+        transport->SetHighSpeedAvailable(true);
+    };
+    callbacks.set_tcp_active = [transport]() {
+        transport->SetHighSpeedAvailable(false);
+    };
+    callbacks.on_failed = []() {};
+    const StepResult result = GetSession(socket)->RunServer(callbacks);
+    if (result == STEP_OK) {
+        ep->_ub_ring->UbrUnlinkLocalShm();
+        LOG_IF(INFO, ubring::FLAGS_ub_trace_verbose)
+            << "Server handshake ends (use ubring) on "
+            << socket->description();
+    } else if (result == STEP_FALLBACK) {
+        LOG_IF(INFO, ubring::FLAGS_ub_trace_verbose)
+            << "Server handshake ends (use tcp) on "
+            << socket->description();
+    }
+    return result;
+}
+#endif
+
+StepResult UBShmServerHandshakeAdapter::RunServerHandshake(
+    butil::IOBuf* source, Socket* socket) {
+#if BRPC_WITH_UBRING
+    if (socket->socket_mode() == SOCKET_MODE_UBRING) {
+        return RunUBShmServerHandshake(source, socket);
+    }
+#endif
+    return RunFallbackServerHandshake(source, socket);
+}
+
+}  // namespace handshake
+}  // namespace brpc
diff --git a/src/brpc/handshake/ubshm_handshake.h b/src/brpc/handshake/ubshm_handshake.h
new file mode 100644
index 0000000000..1bf1bb9d9b
--- /dev/null
+++ b/src/brpc/handshake/ubshm_handshake.h
@@ -0,0 +1,84 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#ifndef BRPC_HANDSHAKE_UBSHM_HANDSHAKE_H
+#define BRPC_HANDSHAKE_UBSHM_HANDSHAKE_H
+
+#include "brpc/handshake/handshake_adapter.h"
+
+namespace brpc {
+namespace handshake {
+
+// Returns the adapter used by the common transport-handshake policy parser.
+// The concrete server executor is private to the implementation.
+HandshakeAdapter* GetUBShmServerHandshakeAdapter();
+
+}  // namespace handshake
+}  // namespace brpc
+
+#if BRPC_WITH_UBRING
+
+#include <cstdint>
+#include <string>
+
+#include <gflags/gflags.h>
+
+#include "butil/macros.h"
+#include "brpc/transport_handshake.h"
+#include "brpc/ubshm/shm/shm_def.h"
+
+namespace brpc {
+namespace ubring {
+
+DECLARE_int32(data_queue_size);
+DECLARE_bool(ub_trace_verbose);
+
+// UBSHM v2 wire payload. HandshakeSession owns framing and ACK exchange;
+// this type and UBShmHandshakeAdapter only handle protocol fields.
+struct HelloMessage {
+    void Serialize(void* data) const;
+    void Deserialize(const void* data);
+    std::string toString() const;
+
+    uint16_t msg_len;
+    uint16_t hello_ver;
+    uint16_t impl_ver;
+    uint64_t len;
+    char shm_name[SHM_MAX_NAME_BUFF_LEN];
+};
+
+class UBShmHandshakeAdapter {
+public:
+    UBShmHandshakeAdapter() = default;
+
+    handshake::HandshakeCodec MakeCodec() const;
+    handshake::StepResult BuildHello(
+        bool enabled, uint64_t len, const char* shm_name,
+        std::string* payload) const;
+    handshake::StepResult ParseHello(
+        const std::string& payload, HelloMessage* message) const;
+
+private:
+    bool NegotiationValid(const HelloMessage& message) const;
+    DISALLOW_COPY_AND_ASSIGN(UBShmHandshakeAdapter);
+};
+
+}  // namespace ubring
+}  // namespace brpc
+
+#endif  // BRPC_WITH_UBRING
+#endif  // BRPC_HANDSHAKE_UBSHM_HANDSHAKE_H
diff --git a/src/brpc/policy/rdma_handshake_protocol.cpp b/src/brpc/policy/rdma_handshake_protocol.cpp
index d948dc6686..fb1e183f1e 100644
--- a/src/brpc/policy/rdma_handshake_protocol.cpp
+++ b/src/brpc/policy/rdma_handshake_protocol.cpp
@@ -17,25 +17,16 @@
 
 #include "brpc/policy/rdma_handshake_protocol.h"
 
-#include "butil/logging.h"
-#include "brpc/destroyable.h"
-#include "brpc/handshake/rdma_handshake.h"
-
 namespace brpc {
 namespace policy {
 
 ParseResult ParseRdmaHandshake(butil::IOBuf* source, Socket* socket,
-                               bool /*read_eof*/, const void* /*arg*/) {
-    return handshake::GetRdmaServerHandshakeAdapter()
-        ->ExecuteServerHandshake(source, socket);
+                               bool read_eof, const void* arg) {
+    return ParseTransportHandshake(source, socket, read_eof, arg);
 }
 
 void ProcessRdmaHandshake(InputMessageBase* msg) {
-    // ParseRdmaHandshake replies inline and only ever returns
-    // NOT_ENOUGH_DATA / TRY_OTHERS / hard errors, never a real message, so this
-    // must never run. Keep a placeholder (required for server registration).
-    DestroyingPtr<InputMessageBase> destroying_msg(msg);
-    CHECK(false) << "ProcessRdmaHandshake should never be called";
+    ProcessTransportHandshake(msg);
 }
 
 }  // namespace policy
diff --git a/src/brpc/policy/rdma_handshake_protocol.h b/src/brpc/policy/rdma_handshake_protocol.h
index e569a4c333..51416e2eee 100644
--- a/src/brpc/policy/rdma_handshake_protocol.h
+++ b/src/brpc/policy/rdma_handshake_protocol.h
@@ -18,36 +18,15 @@
 #ifndef BRPC_POLICY_RDMA_HANDSHAKE_PROTOCOL_H
 #define BRPC_POLICY_RDMA_HANDSHAKE_PROTOCOL_H
 
-// NOTE: This file is intentionally INDEPENDENT of BRPC_WITH_RDMA. A server may
-// run in TCP mode either because it was built without RDMA, or because RDMA was
-// not enabled at runtime. In both cases an RDMA client that connects to it will
-// send an RDMA handshake magic ("RDMA" for v2, "RDM3" for v3) first. Without
-// special handling the server treats those bytes as an unknown protocol and
-// closes the connection, so the client (blocked reading the server hello) only
-// sees EOF and cannot fall back to TCP.
-//
-// To let the client fall back on the SAME connection, the server recognizes the
-// RDMA handshake as a "first-class" protocol (magic in the first 4 bytes,
-// PROTOCOL_RDMA_HANDSHAKE is ordered before PROTOCOL_HTTP), replies a hello with
-// an incompatible version so the client rejects it and downgrades to TCP, then
-// drains the client's subsequent ACK and lets normal RPC parsing continue.
-
-#include "butil/iobuf.h"
-#include "brpc/input_message_base.h"
-#include "brpc/parse_result.h"
-#include "brpc/socket.h"
+// Compatibility facade. New code should include
+// transport_handshake_protocol.h and use ParseTransportHandshake.
+#include "brpc/policy/transport_handshake_protocol.h"
 
 namespace brpc {
 namespace policy {
 
-// Parse binary format of rdma handshake.
 ParseResult ParseRdmaHandshake(butil::IOBuf* source, Socket* socket,
                                bool read_eof, const void* arg);
-
-// Actions to a rdma handshake request, which is left unimplemented.
-// All requests are processed in the parsing process. This function
-// must be declared since server only enables rdma handshake as a
-// server-side protocol when this function is declared.
 void ProcessRdmaHandshake(InputMessageBase* msg);
 
 }  // namespace policy
diff --git a/src/brpc/policy/transport_handshake_protocol.cpp b/src/brpc/policy/transport_handshake_protocol.cpp
new file mode 100644
index 0000000000..bdfefb352e
--- /dev/null
+++ b/src/brpc/policy/transport_handshake_protocol.cpp
@@ -0,0 +1,53 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "brpc/policy/transport_handshake_protocol.h"
+
+#include "butil/logging.h"
+#include "brpc/destroyable.h"
+#include "brpc/handshake/rdma_handshake.h"
+#include "brpc/handshake/ubshm_handshake.h"
+#include "brpc/transport_handshake.h"
+
+namespace brpc {
+namespace policy {
+
+ParseResult ParseTransportHandshake(butil::IOBuf* source, Socket* socket,
+                                     bool /*read_eof*/, const void* /*arg*/) {
+    if (socket->parsing_context() != NULL) {
+        handshake::ServerHandshakeContext* context =
+            static_cast<handshake::ServerHandshakeContext*>(
+                socket->parsing_context());
+        CHECK(context->adapter() != NULL);
+        return context->adapter()->ExecuteServerHandshake(source, socket);
+    }
+
+    const char* first = static_cast<const char*>(source->fetch1());
+    handshake::HandshakeAdapter* adapter =
+        first != NULL && *first == 'U'
+        ? handshake::GetUBShmServerHandshakeAdapter()
+        : handshake::GetRdmaServerHandshakeAdapter();
+    return adapter->ExecuteServerHandshake(source, socket);
+}
+
+void ProcessTransportHandshake(InputMessageBase* msg) {
+    DestroyingPtr<InputMessageBase> destroying_msg(msg);
+    CHECK(false) << "ProcessTransportHandshake should never be called";
+}
+
+}  // namespace policy
+}  // namespace brpc
diff --git a/src/brpc/policy/transport_handshake_protocol.h b/src/brpc/policy/transport_handshake_protocol.h
new file mode 100644
index 0000000000..f4a1fe9acc
--- /dev/null
+++ b/src/brpc/policy/transport_handshake_protocol.h
@@ -0,0 +1,44 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#ifndef BRPC_POLICY_TRANSPORT_HANDSHAKE_PROTOCOL_H
+#define BRPC_POLICY_TRANSPORT_HANDSHAKE_PROTOCOL_H
+
+// This policy is intentionally independent of BRPC_WITH_RDMA and
+// BRPC_WITH_UBRING. A plain TCP server must recognize an upgrade hello and
+// return a disabled hello so the client can continue with TCP on the same
+// connection.
+
+#include "butil/iobuf.h"
+#include "brpc/input_message_base.h"
+#include "brpc/parse_result.h"
+#include "brpc/socket.h"
+
+namespace brpc {
+namespace policy {
+
+ParseResult ParseTransportHandshake(butil::IOBuf* source, Socket* socket,
+                                     bool read_eof, const void* arg);
+
+// Upgrade handshakes are completed inline by the parser. This placeholder is
+// required for server-side protocol registration and must never be invoked.
+void ProcessTransportHandshake(InputMessageBase* msg);
+
+}  // namespace policy
+}  // namespace brpc
+
+#endif  // BRPC_POLICY_TRANSPORT_HANDSHAKE_PROTOCOL_H
diff --git a/src/brpc/transport_handshake.cpp b/src/brpc/transport_handshake.cpp
index aece41c83c..b351c01864 100644
--- a/src/brpc/transport_handshake.cpp
+++ b/src/brpc/transport_handshake.cpp
@@ -25,11 +25,18 @@
 namespace brpc {
 namespace handshake {
 
-ServerHandshakeContext* ServerHandshakeContext::Create() {
-    return butil::get_object<ServerHandshakeContext>();
+ServerHandshakeContext* ServerHandshakeContext::Create(
+    HandshakeAdapter* adapter) {
+    ServerHandshakeContext* context =
+        butil::get_object<ServerHandshakeContext>();
+    if (context != NULL) {
+        context->_adapter = adapter;
+    }
+    return context;
 }
 
 void ServerHandshakeContext::Destroy() {
+    _adapter = NULL;
     butil::return_object(this);
 }
 
diff --git a/src/brpc/transport_handshake.h b/src/brpc/transport_handshake.h
index 7ac4422395..cc206dee62 100644
--- a/src/brpc/transport_handshake.h
+++ b/src/brpc/transport_handshake.h
@@ -34,11 +34,19 @@ class Socket;
 
 namespace handshake {
 
-// Marker context retained by InputMessenger between the hello and ACK parse
-// calls. It is wire-format agnostic and reusable by every upgrade protocol.
+class HandshakeAdapter;
+
+// Context retained by InputMessenger between the hello and ACK parse calls.
+// Remembering the selected stateless adapter is necessary because ACK frames
+// have no magic and cannot be dispatched from their bytes alone.
 struct ServerHandshakeContext : public Destroyable {
-    static ServerHandshakeContext* Create();
+    ServerHandshakeContext() : _adapter(NULL) {}
+    static ServerHandshakeContext* Create(HandshakeAdapter* adapter);
+    HandshakeAdapter* adapter() const { return _adapter; }
     void Destroy() override;
+
+private:
+    HandshakeAdapter* _adapter;
 };
 
 // Protocol adapters may use transport-specific intermediate values, but the
diff --git a/src/brpc/ubshm/ub_endpoint.cpp b/src/brpc/ubshm/ub_endpoint.cpp
index d671fb61af..c3b96b95f0 100644
--- a/src/brpc/ubshm/ub_endpoint.cpp
+++ b/src/brpc/ubshm/ub_endpoint.cpp
@@ -20,16 +20,12 @@
 #include <errno.h>
 
 #include <gflags/gflags.h>
-#include <array>
-#include "butil/fd_utility.h"
 #include "butil/logging.h"                   // CHECK, LOG
-#include "butil/sys_byteorder.h"             // HostToNet,NetToHost
 #include "bthread/bthread.h"
 #include "brpc/errno.pb.h"
 #include "brpc/event_dispatcher.h"
 #include "brpc/input_messenger.h"
 #include "brpc/socket.h"
-#include "brpc/reloadable_flags.h"
 #include "brpc/ubshm/ub_helper.h"
 #include "brpc/ubshm/ub_endpoint.h"
 #include "brpc/ubshm/shm/shm_def.h"
@@ -44,9 +40,6 @@ DECLARE_bool(log_connection_close);
 namespace ubring {
 
 extern bool g_skip_ub_init;
-DEFINE_int32(data_queue_size, 4, "data queue size for UB");
-DEFINE_bool(ub_trace_verbose, false, "Print log message verbosely");
-BRPC_VALIDATE_GFLAG(ub_trace_verbose, brpc::PassValidate);
 DEFINE_int32(ub_poller_num, 1, "Poller number in ub polling mode.");
 DEFINE_bool(ub_poller_yield, false, "Yield thread in RDMA polling mode.");
 DEFINE_bool(ub_edisp_unsched, false, "Disable event dispatcher schedule");
@@ -56,71 +49,8 @@ static const size_t MIN_ONCE_READ = 4096;
 static const size_t MAX_ONCE_READ = 524288;
 static const size_t IOBUF_IOV_MAX = 256;
 
-static const char* MAGIC_STR = "UB";
-static const size_t MAGIC_STR_LEN = 2;
-static const size_t HELLO_MSG_LEN_MIN = 64;
-static const size_t ACK_MSG_LEN = 4;
-static uint16_t g_ub_hello_msg_len = 64;
-static uint16_t g_ub_hello_version = 2;
-static uint16_t g_ub_impl_version = 1;
-
-static const uint32_t ACK_MSG_UB_OK = 0x1;
-
 static butil::Mutex* g_ubring_resource_mutex = NULL;
 
-void HelloMessage::Serialize(void* data) const {
-    char* current_pos = static_cast<char*>(data);
-    const uint16_t net_msg_len = butil::HostToNet16(msg_len);
-    memcpy(current_pos, &net_msg_len, sizeof(net_msg_len));
-    current_pos += sizeof(net_msg_len);
-    const uint16_t net_hello_ver = butil::HostToNet16(hello_ver);
-    memcpy(current_pos, &net_hello_ver, sizeof(net_hello_ver));
-    current_pos += sizeof(net_hello_ver);
-    const uint16_t net_impl_ver = butil::HostToNet16(impl_ver);
-    memcpy(current_pos, &net_impl_ver, sizeof(net_impl_ver));
-    current_pos += sizeof(net_impl_ver);
-    const uint64_t net_len = butil::HostToNet64(len);
-    memcpy(current_pos, &net_len, sizeof(net_len));
-    current_pos += sizeof(net_len);
-    memcpy(current_pos, shm_name, SHM_MAX_NAME_BUFF_LEN);
-}
-
-void HelloMessage::Deserialize(const void* data) {
-    const char* current_pos = static_cast<const char*>(data);
-    uint16_t net_msg_len;
-    memcpy(&net_msg_len, current_pos, sizeof(net_msg_len));
-    msg_len = butil::NetToHost16(net_msg_len);
-    current_pos += sizeof(net_msg_len);
-    uint16_t net_hello_ver;
-    memcpy(&net_hello_ver, current_pos, sizeof(net_hello_ver));
-    hello_ver = butil::NetToHost16(net_hello_ver);
-    current_pos += sizeof(net_hello_ver);
-    uint16_t net_impl_ver;
-    memcpy(&net_impl_ver, current_pos, sizeof(net_impl_ver));
-    impl_ver = butil::NetToHost16(net_impl_ver);
-    current_pos += sizeof(net_impl_ver);
-    uint64_t net_len;
-    memcpy(&net_len, current_pos, sizeof(net_len));
-    len = butil::NetToHost64(net_len);
-    current_pos += sizeof(net_len);
-    memcpy(shm_name, current_pos, SHM_MAX_NAME_BUFF_LEN);
-}
-
-std::string HelloMessage::toString() const {
-    constexpr size_t MAX_LEN = 16 + 6 + 16 + 6 + 16 + 6 + 20 + 6 + SHM_MAX_NAME_BUFF_LEN + 32;
-    std::array<char, MAX_LEN> buf;
-    int n = snprintf(buf.data(), buf.size(),
-        "msg_len=%u, hello_ver=%u, impl_ver=%u, len=%lu, shm_name=%.*s",
-        msg_len,
-        hello_ver,
-        impl_ver,
-        static_cast<unsigned long>(len),  // compatible with 32/64-bit
-        static_cast<int>(SHM_MAX_NAME_BUFF_LEN),  // limit max output length
-        shm_name
-    );
-    return std::string(buf.data(), static_cast<size_t>(n));
-}
-
 UBShmEndpoint::UBShmEndpoint(Socket* s)
     : _socket(s)
     , _socket_id(s ? s->id() : INVALID_SOCKET_ID)
@@ -141,316 +71,6 @@ void UBShmEndpoint::Reset() {
     _cq_sid = INVALID_SOCKET_ID;
 }
 
-void UBConnect::StartConnect(const Socket* socket,
-                               void (*done)(int err, void* data),
-                               void* data) {
-    UBShmTransport* ub_transport = UBShmTransport::Get(socket);
-    CHECK(ub_transport->_ub_ep != NULL);
-    SocketUniquePtr s;
-    if (Socket::Address(socket->id(), &s) != 0) {
-        return;
-    }
-    if (!IsUBAvailable()) {
-        ub_transport->FallbackToTcp();
-        done(0, data);
-        return;
-    }
-    _done = done;
-    _data = data;
-    bthread_t tid;
-    bthread_attr_t attr = BTHREAD_ATTR_NORMAL;
-    bthread_attr_set_name(&attr, "UBProcessHandshakeAtClient");
-    if (bthread_start_background(&tid, &attr,
-                UBShmTransport::ProcessHandshakeAtClient, ub_transport) < 0) {
-        LOG(FATAL) << "Fail to start handshake bthread";
-        Run();
-    } else {
-        s.release();
-    }
-}
-
-void UBConnect::StopConnect(Socket* socket) { }
-
-void UBConnect::Run() {
-    _done(errno, _data);
-}
-
-}  // namespace ubring
-
-// Keep the wire constants and endpoint resource implementation in ubring,
-// while the connection-control state machine belongs to the Transport layer.
-using namespace ubring;
-
-void UBShmTransport::StartServerHandshake() {
-    if (!IsUBAvailable()) {
-        FallbackToTcp();
-        return;
-    }
-    bthread_t tid;
-    handshake_session()->SetPhase(S_HELLO_WAIT);
-    SocketUniquePtr socket;
-    _socket->ReAddress(&socket);
-    bthread_attr_t attr = BTHREAD_ATTR_NORMAL;
-    bthread_attr_set_name(&attr, "UBProcessHandshakeAtServer");
-    if (bthread_start_background(
-            &tid, &attr, ProcessHandshakeAtServer, this) < 0) {
-        handshake_session()->SetPhase(UNINIT);
-        LOG(FATAL) << "Fail to start handshake bthread";
-    } else {
-        socket.release();
-    }
-}
-bool HelloNegotiationValid(HelloMessage& msg) {
-    if (msg.hello_ver == g_ub_hello_version &&
-        msg.impl_ver == g_ub_impl_version) {
-        // This can be modified for future compatibility
-        return true;
-    }
-    return false;
-}
-
-static handshake::HandshakeCodec MakeUBHandshakeCodec() {
-    handshake::HandshakeCodec codec{};
-    codec.protocol_version = 2;
-    codec.hello_frame = handshake::FrameSpec(
-        MAGIC_STR, MAGIC_STR_LEN, HELLO_MSG_LEN_MIN, HELLO_MSG_LEN_MIN,
-        handshake::FrameSpec::FIXED);
-    codec.ack_frame = handshake::FrameSpec(
-        NULL, 0, ACK_MSG_LEN, ACK_MSG_LEN, handshake::FrameSpec::FIXED);
-    codec.build_ack = [](bool enabled, std::string* payload) {
-        const uint32_t flags_be = butil::HostToNet32(
-            enabled ? ACK_MSG_UB_OK : 0);
-        payload->assign(reinterpret_cast<const char*>(&flags_be),
-                        sizeof(flags_be));
-        return handshake::STEP_OK;
-    };
-    codec.parse_ack = [](const std::string& payload, bool* enabled) {
-        if (payload.size() != ACK_MSG_LEN) {
-            errno = EPROTO;
-            return handshake::STEP_ERROR;
-        }
-        uint32_t flags_be = 0;
-        memcpy(&flags_be, payload.data(), sizeof(flags_be));
-        *enabled = (butil::NetToHost32(flags_be) & ACK_MSG_UB_OK) != 0;
-        return handshake::STEP_OK;
-    };
-    return codec;
-}
-
-void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
-    UBShmTransport* ub_transport = static_cast<UBShmTransport*>(arg);
-    UBShmEndpoint* ep = ub_transport->_ub_ep;
-    SocketUniquePtr s(ep->_socket);
-    UBConnect::RunGuard rg((UBConnect*)s->_app_connect.get());
-
-    LOG_IF(INFO, FLAGS_ub_trace_verbose) 
-        << "Start handshake on " << s->_local_side;
-
-    size_t local_shm_len = (size_t)(FLAGS_data_queue_size) * MB_TO_BYTE;
-    SHM local_trx_shm = {NULL, local_shm_len, 0, {0}, (uint32_t)s->fd()};
-    auto shm_name_str = butil::endpoint2str(s->local_side());
-    const char* shm_name = shm_name_str.c_str();
-    HelloMessage remote_msg{};
-
-    handshake::ClientHandshakeCallbacks callbacks{};
-    callbacks.phases = handshake::HandshakePhases{
-        C_ALLOC_SHM, C_HELLO_SEND, C_HELLO_WAIT,
-        C_MAP_REMOTE_SHM, C_ACK_SEND, 0};
-    callbacks.codec = MakeUBHandshakeCodec();
-    callbacks.codec.build_hello = [&](bool enabled, std::string* payload) {
-        CHECK(enabled);
-        HelloMessage local_msg{};
-        local_msg.msg_len = g_ub_hello_msg_len;
-        local_msg.hello_ver = g_ub_hello_version;
-        local_msg.impl_ver = g_ub_impl_version;
-        local_msg.len = local_shm_len;
-        memcpy(local_msg.shm_name, local_trx_shm.name,
-               SHM_MAX_NAME_BUFF_LEN);
-        payload->assign(HELLO_MSG_LEN_MIN - MAGIC_STR_LEN, '\0');
-        local_msg.Serialize(&(*payload)[0]);
-        LOG_IF(INFO, FLAGS_ub_trace_verbose)
-            << "client handshake message : " << local_msg.toString();
-        return handshake::STEP_OK;
-    };
-    callbacks.codec.parse_hello = [&](const std::string& payload) {
-        if (payload.size() != HELLO_MSG_LEN_MIN - MAGIC_STR_LEN) {
-            errno = EPROTO;
-            return handshake::STEP_ERROR;
-        }
-        remote_msg.Deserialize(payload.data());
-        if (remote_msg.msg_len < HELLO_MSG_LEN_MIN) {
-            errno = EPROTO;
-            return handshake::STEP_ERROR;
-        }
-        if (!HelloNegotiationValid(remote_msg)) {
-            LOG(WARNING) << "Fail to negotiate with server, fallback to tcp:"
-                         << s->description();
-            return handshake::STEP_FALLBACK;
-        }
-        return handshake::STEP_OK;
-    };
-    callbacks.prepare_resources = [&]() {
-        if (ep->AllocateClientResources(&local_trx_shm, shm_name) == 0) {
-            return handshake::STEP_OK;
-        }
-        LOG(WARNING) << "Fallback to tcp:" << s->description();
-        errno = 0;
-        return handshake::STEP_FALLBACK;
-    };
-    callbacks.negotiate_resources = [&]() {
-        if (ep->_ub_ring->UbrMapRemoteShm(&local_trx_shm, shm_name) == 0) {
-            return handshake::STEP_OK;
-        }
-        LOG(WARNING) << "Fail to map the remote shm, fallback to tcp:"
-                     << s->description();
-        return handshake::STEP_FALLBACK;
-    };
-    callbacks.set_high_speed_active = [ub_transport]() {
-        ub_transport->SetHighSpeedAvailable(true);
-    };
-    callbacks.set_tcp_active = [ub_transport]() {
-        ub_transport->SetHighSpeedAvailable(false);
-    };
-    callbacks.on_failed = [&]() {
-        const int saved_errno = errno != 0 ? errno : EPROTO;
-        s->SetFailed(saved_errno,
-                     "Fail to complete ubring handshake from %s: %s",
-                     s->description().c_str(), berror(saved_errno));
-    };
-
-    const handshake::StepResult result =
-        ub_transport->handshake_session()->RunClient(callbacks);
-    if (result == handshake::STEP_OK) {
-        ep->_ub_ring->UbrUnlinkLocalShm();
-        LOG_IF(INFO, FLAGS_ub_trace_verbose) 
-            << "Client handshake ends (use ubring) on " << s->description();
-    } else if (result == handshake::STEP_FALLBACK) {
-        LOG_IF(INFO, FLAGS_ub_trace_verbose) 
-            << "Client handshake ends (use tcp) on " << s->description();
-    }
-
-    errno = 0;
-
-    return NULL;
-}
-
-void* UBShmTransport::ProcessHandshakeAtServer(void* arg) {
-    UBShmTransport* ub_transport = static_cast<UBShmTransport*>(arg);
-    UBShmEndpoint* ep = ub_transport->_ub_ep;
-    SocketUniquePtr s(ep->_socket);
-
-    LOG_IF(INFO, FLAGS_ub_trace_verbose)
-        << "Start handshake on " << s->description();
-
-    HelloMessage remote_msg{};
-
-    handshake::ServerHandshakeCallbacks callbacks{};
-    callbacks.phases = handshake::HandshakePhases{
-        S_ALLOC_SHM, S_HELLO_SEND, S_HELLO_WAIT,
-        S_ALLOC_SHM, 0, S_ACK_WAIT};
-    callbacks.fallback_on_not_mine = true;
-    callbacks.input = NULL;
-    handshake::HandshakeCodec codec = MakeUBHandshakeCodec();
-    codec.parse_hello = [&](const std::string& payload) {
-        if (payload.size() != HELLO_MSG_LEN_MIN - MAGIC_STR_LEN) {
-            errno = EPROTO;
-            return handshake::STEP_ERROR;
-        }
-        remote_msg.Deserialize(payload.data());
-        LOG_IF(INFO, FLAGS_ub_trace_verbose)
-            << "server receive handshake message : " << remote_msg.toString();
-        if (remote_msg.msg_len < HELLO_MSG_LEN_MIN) {
-            errno = EPROTO;
-            return handshake::STEP_ERROR;
-        }
-        if (!HelloNegotiationValid(remote_msg)) {
-            return handshake::STEP_FALLBACK;
-        }
-        return handshake::STEP_OK;
-    };
-    codec.build_hello = [&](bool enabled, std::string* payload) {
-        HelloMessage local_msg{};
-        local_msg.msg_len = g_ub_hello_msg_len;
-        if (enabled) {
-            local_msg.hello_ver = g_ub_hello_version;
-            local_msg.impl_ver = g_ub_impl_version;
-            local_msg.len = (FLAGS_data_queue_size) * MB_TO_BYTE;
-            memcpy(local_msg.shm_name, remote_msg.shm_name,
-                   SHM_MAX_NAME_BUFF_LEN);
-        }
-        payload->assign(HELLO_MSG_LEN_MIN - MAGIC_STR_LEN, '\0');
-        local_msg.Serialize(&(*payload)[0]);
-        return handshake::STEP_OK;
-    };
-    callbacks.codecs.push_back(codec);
-    callbacks.prepare_resources = [&]() {
-        ubring::SHM remote_trx_shm = {
-            NULL, remote_msg.len, 0, {0}, (uint32_t)ep->_socket->fd()};
-        strncpy(remote_trx_shm.name, remote_msg.shm_name, SHM_MAX_NAME_BUFF_LEN);
-
-        size_t local_shm_len = (size_t)(FLAGS_data_queue_size) * MB_TO_BYTE;
-        // server-side shared memory name
-        ubring::SHM local_trx_shm = {
-            NULL, local_shm_len, 0, {0}, (uint32_t)ep->_socket->fd()};
-        char client_name[SHM_MAX_NAME_BUFF_LEN];
-        strncpy(client_name, remote_msg.shm_name, SHM_MAX_NAME_BUFF_LEN);
-
-        char *client_ip_port = strrchr(client_name, '_');
-        if (client_ip_port != NULL) {
-            *client_ip_port = '\0';
-        }
-        int result = snprintf(local_trx_shm.name, SHM_MAX_NAME_BUFF_LEN, "%s_%s",
-            client_name, SERVER_SHM_NAME_SUFFIX);
-        if (UNLIKELY(result < 0)) {
-            LOG(WARNING) << "Copy client shared memory name failed, ret=" << result;
-            return handshake::STEP_FALLBACK;
-        }
-        if (ep->AllocateServerResources(
-                &remote_trx_shm, &local_trx_shm) < 0) {
-            LOG(WARNING) << "Fail to allocate ub resources, fallback to tcp:"
-                         << s->description();
-            return handshake::STEP_FALLBACK;
-        }
-        return handshake::STEP_OK;
-    };
-    callbacks.negotiate_resources = []() {
-        return handshake::STEP_OK;
-    };
-    callbacks.validate_established = []() {
-        return handshake::STEP_OK;
-    };
-    callbacks.set_high_speed_active = [ub_transport]() {
-        ub_transport->SetHighSpeedAvailable(true);
-    };
-    callbacks.set_tcp_active = [ub_transport]() {
-        ub_transport->SetHighSpeedAvailable(false);
-    };
-    callbacks.on_failed = [&]() {
-        const int saved_errno = errno != 0 ? errno : EPROTO;
-        s->SetFailed(saved_errno,
-                     "Fail to complete ubring handshake from %s: %s",
-                     s->description().c_str(), berror(saved_errno));
-    };
-
-    const handshake::StepResult result =
-        ub_transport->handshake_session()->RunServer(callbacks);
-    if (result == handshake::STEP_OK) {
-        ep->_ub_ring->UbrUnlinkLocalShm();
-        LOG_IF(INFO, FLAGS_ub_trace_verbose)
-            << "Server handshake ends (use ubring) on " << s->description();
-    } else if (result == handshake::STEP_FALLBACK) {
-        LOG_IF(INFO, FLAGS_ub_trace_verbose) 
-            << "Server handshake ends (use tcp) on " << s->description();
-    }
-    if (result != handshake::STEP_ERROR) {
-        ub_transport->TryReadOnTcp();
-    }
-
-    return NULL;
-}
-
-namespace ubring {
-
 bool UBShmEndpoint::IsWritable() const {
     if (BAIDU_UNLIKELY(g_skip_ub_init)) {
         // Just for UT
diff --git a/src/brpc/ubshm/ub_endpoint.h b/src/brpc/ubshm/ub_endpoint.h
index 794311972c..e018d30b44 100644
--- a/src/brpc/ubshm/ub_endpoint.h
+++ b/src/brpc/ubshm/ub_endpoint.h
@@ -20,15 +20,13 @@
 
 #if BRPC_WITH_UBRING
 
-#include <cstring>
-#include <iostream>
-#include <string>
-#include <vector>
 #include <functional>
+#include <vector>
 #include "butil/atomicops.h"
 #include "butil/iobuf.h"
 #include "butil/macros.h"
 #include "butil/containers/mpsc_queue.h"
+#include "brpc/handshake/ubshm_handshake.h"
 #include "brpc/socket.h"
 #include "brpc/ubshm/ub_helper.h"
 #include "brpc/ubshm/ub_ring.h"
@@ -38,24 +36,15 @@
 namespace brpc {
 class Socket;
 class UBShmTransport;
+namespace handshake {
+class UBShmServerHandshakeAdapter;
+}
 namespace ubring {
 
 DECLARE_int32(ub_poller_num);
 DECLARE_bool(ub_edisp_unsched);
 DECLARE_bool(ub_disable_bthread);
 
-struct HelloMessage {
-    void Serialize(void* data) const;
-    void Deserialize(const void* data);
-    std::string toString() const;
-
-    uint16_t msg_len;
-    uint16_t hello_ver;
-    uint16_t impl_ver;
-    uint64_t len;
-    char shm_name[SHM_MAX_NAME_BUFF_LEN];
-};
-
 class UBConnect : public AppConnect {
 public:
     void StartConnect(const Socket* socket,
@@ -77,6 +66,7 @@ class BAIDU_CACHELINE_ALIGNMENT UBShmEndpoint : public SocketUser {
 friend class UBConnect;
 friend class Socket;
 friend class ::brpc::UBShmTransport;
+friend class ::brpc::handshake::UBShmServerHandshakeAdapter;
 public:
     explicit UBShmEndpoint(Socket* s);
     ~UBShmEndpoint() override;
diff --git a/src/brpc/ubshm_transport.cpp b/src/brpc/ubshm_transport.cpp
index 7c3daac6bc..f6c99ab2a9 100644
--- a/src/brpc/ubshm_transport.cpp
+++ b/src/brpc/ubshm_transport.cpp
@@ -17,10 +17,16 @@
 
 #if BRPC_WITH_UBRING
 
+#include <cstring>
+
 #include "brpc/ubshm_transport.h"
 #include "brpc/adapter_transport.h"
+#include "brpc/errno.pb.h"
+#include "brpc/handshake/ubshm_handshake.h"
+#include "brpc/ubshm/common/common.h"
 #include "brpc/ubshm/ub_endpoint.h"
 #include "brpc/ubshm/ub_helper.h"
+#include "brpc/ubshm/ubr_trx.h"
 
 namespace brpc {
 DECLARE_bool(usercode_in_coroutine);
@@ -28,6 +34,45 @@ DECLARE_bool(usercode_in_pthread);
 
 extern SocketVarsCollector *g_vars;
 
+namespace ubring {
+
+void UBConnect::StartConnect(const Socket* socket,
+                             void (*done)(int err, void* data),
+                             void* data) {
+    UBShmTransport* transport = UBShmTransport::Get(socket);
+    CHECK(transport->_ub_ep != NULL);
+    SocketUniquePtr ptr;
+    if (Socket::Address(socket->id(), &ptr) != 0) {
+        return;
+    }
+    if (!IsUBAvailable()) {
+        transport->FallbackToTcp();
+        done(0, data);
+        return;
+    }
+    _done = done;
+    _data = data;
+    bthread_t tid;
+    bthread_attr_t attr = BTHREAD_ATTR_NORMAL;
+    bthread_attr_set_name(&attr, "UBProcessHandshakeAtClient");
+    if (bthread_start_background(
+            &tid, &attr, UBShmTransport::ProcessHandshakeAtClient,
+            transport) < 0) {
+        LOG(FATAL) << "Fail to start handshake bthread";
+        Run();
+    } else {
+        ptr.release();
+    }
+}
+
+void UBConnect::StopConnect(Socket*) {}
+
+void UBConnect::Run() {
+    _done(errno, _data);
+}
+
+}  // namespace ubring
+
 UBShmTransport* UBShmTransport::Get(const Socket* socket) {
     const AdapterTransport* adapter = AdapterTransport::Get(socket);
     Transport* transport = adapter->high_speed_transport();
@@ -55,8 +100,96 @@ void UBShmTransport::FallbackToTcp() {
     adapter_transport()->FallbackToTcp();
 }
 
-void UBShmTransport::TryReadOnTcp() {
-    adapter_transport()->TryReadOnTcp();
+void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
+    UBShmTransport* transport = static_cast<UBShmTransport*>(arg);
+    ubring::UBShmEndpoint* ep = transport->_ub_ep;
+    SocketUniquePtr socket(ep->_socket);
+    ubring::UBConnect::RunGuard guard(
+        static_cast<ubring::UBConnect*>(socket->_app_connect.get()));
+
+    LOG_IF(INFO, ubring::FLAGS_ub_trace_verbose)
+        << "Start handshake on " << socket->_local_side;
+
+    const size_t local_shm_len =
+        static_cast<size_t>(ubring::FLAGS_data_queue_size) * MB_TO_BYTE;
+    ubring::SHM local_trx_shm = {
+        NULL, local_shm_len, 0, {0},
+        static_cast<uint32_t>(socket->fd())};
+    const auto shm_name_str = butil::endpoint2str(socket->local_side());
+    const char* const shm_name = shm_name_str.c_str();
+    ubring::HelloMessage remote{};
+    ubring::UBShmHandshakeAdapter wire;
+
+    handshake::ClientHandshakeCallbacks callbacks{};
+    callbacks.phases = handshake::HandshakePhases{
+        C_ALLOC_SHM, C_HELLO_SEND, C_HELLO_WAIT,
+        C_MAP_REMOTE_SHM, C_ACK_SEND, 0};
+    callbacks.codec = wire.MakeCodec();
+    callbacks.codec.build_hello = [&](bool enabled, std::string* payload) {
+        CHECK(enabled);
+        const handshake::StepResult result = wire.BuildHello(
+            true, local_shm_len, local_trx_shm.name, payload);
+        if (result == handshake::STEP_OK) {
+            ubring::HelloMessage local{};
+            local.Deserialize(payload->data());
+            LOG_IF(INFO, ubring::FLAGS_ub_trace_verbose)
+                << "client handshake message : " << local.toString();
+        }
+        return result;
+    };
+    callbacks.codec.parse_hello = [&](const std::string& payload) {
+        const handshake::StepResult result = wire.ParseHello(payload, &remote);
+        if (result == handshake::STEP_FALLBACK) {
+            LOG(WARNING)
+                << "Fail to negotiate with server, fallback to tcp:"
+                << socket->description();
+        }
+        return result;
+    };
+    callbacks.prepare_resources = [&]() {
+        if (ep->AllocateClientResources(&local_trx_shm, shm_name) == 0) {
+            return handshake::STEP_OK;
+        }
+        LOG(WARNING) << "Fallback to tcp:" << socket->description();
+        errno = 0;
+        return handshake::STEP_FALLBACK;
+    };
+    callbacks.negotiate_resources = [&]() {
+        if (ep->_ub_ring->UbrMapRemoteShm(
+                &local_trx_shm, shm_name) == 0) {
+            return handshake::STEP_OK;
+        }
+        LOG(WARNING) << "Fail to map the remote shm, fallback to tcp:"
+                     << socket->description();
+        return handshake::STEP_FALLBACK;
+    };
+    callbacks.set_high_speed_active = [transport]() {
+        transport->SetHighSpeedAvailable(true);
+    };
+    callbacks.set_tcp_active = [transport]() {
+        transport->SetHighSpeedAvailable(false);
+    };
+    callbacks.on_failed = [&]() {
+        const int saved_errno = errno != 0 ? errno : EPROTO;
+        socket->SetFailed(saved_errno,
+                          "Fail to complete ubring handshake from %s: %s",
+                          socket->description().c_str(), berror(saved_errno));
+    };
+
+    const handshake::StepResult result =
+        transport->handshake_session()->RunClient(callbacks);
+    if (result == handshake::STEP_OK) {
+        ep->_ub_ring->UbrUnlinkLocalShm();
+        LOG_IF(INFO, ubring::FLAGS_ub_trace_verbose)
+            << "Client handshake ends (use ubring) on "
+            << socket->description();
+    } else if (result == handshake::STEP_FALLBACK) {
+        LOG_IF(INFO, ubring::FLAGS_ub_trace_verbose)
+            << "Client handshake ends (use tcp) on "
+            << socket->description();
+    }
+    errno = 0;
+    return NULL;
 }
 
 void UBShmTransport::Init(Socket *socket, const SocketOptions &options) {
diff --git a/src/brpc/ubshm_transport.h b/src/brpc/ubshm_transport.h
index eba126e63d..abdd25e069 100644
--- a/src/brpc/ubshm_transport.h
+++ b/src/brpc/ubshm_transport.h
@@ -25,11 +25,15 @@
 
 namespace brpc {
 class AdapterTransport;
+namespace handshake {
+class UBShmServerHandshakeAdapter;
+}
 class UBShmTransport : public Transport {
     friend class TransportFactory;
     friend class AdapterTransport;
     friend class ubring::UBShmEndpoint;
     friend class ubring::UBConnect;
+    friend class handshake::UBShmServerHandshakeAdapter;
 public:
     enum HandshakeState {
         UNINIT = 0x0,
@@ -67,14 +71,11 @@ class UBShmTransport : public Transport {
     int handshake_phase() const;
     int handshake_version() const;
     static void* ProcessHandshakeAtClient(void* arg);
-    static void* ProcessHandshakeAtServer(void* arg);
 private:
     AdapterTransport* adapter_transport() const;
     handshake::HandshakeSession* handshake_session() const;
     void FallbackToTcp();
-    void TryReadOnTcp();
     void SetHighSpeedAvailable(bool available);
-    void StartServerHandshake();
 
     static bool OptionsAvailableForUB(const ChannelOptions* opt);
     static bool OptionsAvailableOverUB(const ServerOptions* opt);
diff --git a/test/brpc_rdma_unittest.cpp b/test/brpc_rdma_unittest.cpp
index bc09756675..06a0c07fa0 100644
--- a/test/brpc_rdma_unittest.cpp
+++ b/test/brpc_rdma_unittest.cpp
@@ -227,9 +227,10 @@ TEST_F(RdmaTest, client_hello_msg_invalid_magic_str) {
     memcpy(data, "PRPC", 4);  // send as normal baidu_std protocol
     ASSERT_EQ(4, write(sockfd, data, 4));
     usleep(100000);  // wait for server to handle the msg
-    // A non-RDMA magic makes ParseRdmaHandshake return TRY_OTHERS and hand the
-    // bytes to other protocols; it does not touch the endpoint state, so it
-    // stays UNINIT (the old blocking handshake used to set FALLBACK_TCP here).
+    // A non-RDMA magic makes the transport-handshake parser return TRY_OTHERS
+    // and hand the bytes to other protocols; it does not touch the endpoint
+    // state, so it stays UNINIT (the old blocking handshake used to set
+    // FALLBACK_TCP here).
     ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
 
     StopServer();
@@ -254,8 +255,8 @@ TEST_F(RdmaTest, client_close_during_hello_send) {
     memcpy(data, "RD", 2);
     ASSERT_EQ(2, write(sockfd1, data, 2));  // break in magic str
     usleep(100000);  // wait for server to handle the msg
-    // Fewer than 4 magic bytes: ParseRdmaHandshake can't tell yet, returns
-    // NOT_ENOUGH_DATA and leaves the endpoint UNINIT (the old blocking
+    // Fewer than 4 magic bytes: the transport-handshake parser can't tell yet,
+    // returns NOT_ENOUGH_DATA and leaves the endpoint UNINIT (the old blocking
     // handshake used to set S_HELLO_WAIT before reading the magic).
     ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
     close(sockfd1);
diff --git a/test/brpc_transport_handshake_unittest.cpp b/test/brpc_transport_handshake_unittest.cpp
index 235a5d847d..bd904b2067 100644
--- a/test/brpc_transport_handshake_unittest.cpp
+++ b/test/brpc_transport_handshake_unittest.cpp
@@ -18,10 +18,16 @@
 #include <gtest/gtest.h>
 
 #include <errno.h>
+#include <sys/socket.h>
+#include <unistd.h>
 #include <cstring>
 #include <string>
 
+#include "butil/fd_guard.h"
 #include "butil/sys_byteorder.h"
+#include "brpc/adapter_transport.h"
+#include "brpc/policy/transport_handshake_protocol.h"
+#include "brpc/socket.h"
 #include "brpc/transport_handshake.h"
 
 namespace brpc {
@@ -95,6 +101,18 @@ static HandshakeCodec MakeTestCodec(std::string* calls = NULL) {
     return codec;
 }
 
+static std::string MakeUBShmHello() {
+    std::string frame(64, '\0');
+    memcpy(&frame[0], "UB", 2);
+    const uint16_t msg_len = butil::HostToNet16(64);
+    const uint16_t hello_ver = butil::HostToNet16(2);
+    const uint16_t impl_ver = butil::HostToNet16(1);
+    memcpy(&frame[2], &msg_len, sizeof(msg_len));
+    memcpy(&frame[4], &hello_ver, sizeof(hello_ver));
+    memcpy(&frame[6], &impl_ver, sizeof(impl_ver));
+    return frame;
+}
+
 TEST(HandshakeFrameTest, supports_two_byte_fixed_magic) {
     const FrameSpec spec = FixedSpec("UB", 2, 6);
     std::string frame;
@@ -280,6 +298,33 @@ TEST(TransportHandshakeTest, server_resumes_at_buffered_ack) {
     ASSERT_EQ(ESTABLISHED, session.phase());
 }
 
+TEST(TransportHandshakeTest, server_resource_failure_falls_back_after_ack) {
+    MemoryHandshakeIO io;
+    HandshakeSession session;
+    session.SetIOForTest(&io);
+    butil::IOBuf source;
+    source.append("HSOK0", 5);
+    IOBufHandshakeInput input(&source);
+    bool tcp_active = false;
+
+    ServerHandshakeCallbacks callbacks{};
+    callbacks.phases = HandshakePhases{11, 12, 13, 14, 15, 16};
+    callbacks.fallback_on_not_mine = false;
+    callbacks.codecs.push_back(MakeTestCodec());
+    callbacks.input = &input;
+    callbacks.prepare_resources = []() { return STEP_FALLBACK; };
+    callbacks.negotiate_resources = []() { return STEP_ERROR; };
+    callbacks.set_high_speed_active = []() {};
+    callbacks.set_tcp_active = [&]() { tcp_active = true; };
+    callbacks.on_failed = []() {};
+
+    ASSERT_EQ(STEP_FALLBACK, session.RunServer(callbacks));
+    ASSERT_EQ("HSNO", io.output());
+    ASSERT_TRUE(source.empty());
+    ASSERT_TRUE(tcp_active);
+    ASSERT_EQ(FALLBACK_TCP, session.phase());
+}
+
 TEST(TransportHandshakeTest, server_falls_back_without_consuming_other_magic) {
     MemoryHandshakeIO io;
     HandshakeSession session;
@@ -339,5 +384,86 @@ TEST(TransportHandshakeTest, server_enters_hello_phase_after_magic_matches) {
     ASSERT_EQ(2UL, source.size());
 }
 
+TEST(TransportHandshakeTest,
+     plain_tcp_server_incrementally_rejects_ubshm_upgrade) {
+    int fds[2];
+    ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, fds));
+    butil::fd_guard peer_fd(fds[1]);
+    SocketOptions options;
+    options.fd = fds[0];
+    SocketId id;
+    ASSERT_EQ(0, Socket::Create(options, &id));
+    SocketUniquePtr socket;
+    ASSERT_EQ(0, Socket::Address(id, &socket));
+
+    const std::string hello = MakeUBShmHello();
+    butil::IOBuf source;
+    source.append(hello.data(), 1);
+    ParseResult result = policy::ParseTransportHandshake(
+        &source, socket.get(), false, NULL);
+    ASSERT_FALSE(result.is_ok());
+    ASSERT_EQ(PARSE_ERROR_NOT_ENOUGH_DATA, result.error());
+    ASSERT_EQ(1UL, source.size());
+    ASSERT_EQ(UNINITIALIZED,
+              AdapterTransport::Get(socket.get())->handshake_phase());
+
+    source.append(hello.data() + 1, hello.size() - 1);
+    result = policy::ParseTransportHandshake(
+        &source, socket.get(), false, NULL);
+    ASSERT_FALSE(result.is_ok());
+    ASSERT_EQ(PARSE_ERROR_NOT_ENOUGH_DATA, result.error());
+    ASSERT_TRUE(source.empty());
+    ASSERT_NE(NULL, socket->parsing_context());
+
+    char reply[64];
+    ASSERT_EQ(sizeof(reply), read(peer_fd, reply, sizeof(reply)));
+    EXPECT_EQ(0, memcmp(reply, "UB", 2));
+    uint16_t reply_len = 0;
+    memcpy(&reply_len, reply + 2, sizeof(reply_len));
+    EXPECT_EQ(64, butil::NetToHost16(reply_len));
+    EXPECT_EQ(0, reply[4]);
+    EXPECT_EQ(0, reply[5]);
+    EXPECT_EQ(0, reply[6]);
+    EXPECT_EQ(0, reply[7]);
+
+    const uint32_t ack = 0;
+    source.append(&ack, sizeof(ack));
+    result = policy::ParseTransportHandshake(
+        &source, socket.get(), false, NULL);
+    ASSERT_FALSE(result.is_ok());
+    ASSERT_EQ(PARSE_ERROR_TRY_OTHERS, result.error());
+    ASSERT_TRUE(source.empty());
+    ASSERT_EQ(FALLBACK_TCP,
+              AdapterTransport::Get(socket.get())->handshake_phase());
+    ASSERT_EQ(NULL, socket->parsing_context());
+    socket->SetFailed();
+}
+
+TEST(TransportHandshakeTest, plain_tcp_server_consumes_coalesced_ubshm_ack) {
+    int fds[2];
+    ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, fds));
+    butil::fd_guard peer_fd(fds[1]);
+    SocketOptions options;
+    options.fd = fds[0];
+    SocketId id;
+    ASSERT_EQ(0, Socket::Create(options, &id));
+    SocketUniquePtr socket;
+    ASSERT_EQ(0, Socket::Address(id, &socket));
+
+    butil::IOBuf source;
+    source.append(MakeUBShmHello());
+    const uint32_t ack = 0;
+    source.append(&ack, sizeof(ack));
+    const ParseResult result = policy::ParseTransportHandshake(
+        &source, socket.get(), false, NULL);
+    ASSERT_FALSE(result.is_ok());
+    ASSERT_EQ(PARSE_ERROR_TRY_OTHERS, result.error());
+    ASSERT_TRUE(source.empty());
+    ASSERT_EQ(FALLBACK_TCP,
+              AdapterTransport::Get(socket.get())->handshake_phase());
+    ASSERT_EQ(NULL, socket->parsing_context());
+    socket->SetFailed();
+}
+
 }  // namespace handshake
 }  // namespace brpc
diff --git a/test/brpc_ubring_unittest.cpp b/test/brpc_ubring_unittest.cpp
index 4340e7a060..683d048c78 100644
--- a/test/brpc_ubring_unittest.cpp
+++ b/test/brpc_ubring_unittest.cpp
@@ -22,6 +22,7 @@
 #include "brpc/socket.h"
 
 #if BRPC_WITH_UBRING
+#include "brpc/handshake/ubshm_handshake.h"
 #include "brpc/ubshm/ub_endpoint.h"
 #include "brpc/ubshm/shm/shm_def.h"
 #include "brpc/ubshm/shm/shm_mgr.h"
@@ -135,6 +136,45 @@ TEST_F(HelloMessageTest, toString_contains_fields) {
     EXPECT_NE(std::string::npos, s.find("UBRING_test"));
 }
 
+TEST(UBShmHandshakeAdapterTest, codec_preserves_v2_wire_format) {
+    brpc::ubring::UBShmHandshakeAdapter adapter;
+    char shm_name[SHM_MAX_NAME_BUFF_LEN] = {0};
+    memcpy(shm_name, "UBRING_test_C", 14);
+
+    std::string payload;
+    ASSERT_EQ(brpc::handshake::STEP_OK,
+              adapter.BuildHello(true, 4 * 1024 * 1024,
+                                 shm_name, &payload));
+    brpc::ubring::HelloMessage decoded{};
+    ASSERT_EQ(brpc::handshake::STEP_OK,
+              adapter.ParseHello(payload, &decoded));
+    EXPECT_EQ(64, decoded.msg_len);
+    EXPECT_EQ(2, decoded.hello_ver);
+    EXPECT_EQ(1, decoded.impl_ver);
+    EXPECT_EQ(4 * 1024 * 1024, decoded.len);
+    EXPECT_EQ(0, memcmp(shm_name, decoded.shm_name,
+                        SHM_MAX_NAME_BUFF_LEN));
+
+    std::string frame;
+    const brpc::handshake::HandshakeCodec codec = adapter.MakeCodec();
+    ASSERT_EQ(brpc::handshake::FRAME_OK,
+              brpc::handshake::FrameCodec::Encode(
+                  codec.hello_frame, payload, &frame));
+    ASSERT_EQ(64, frame.size());
+    EXPECT_EQ("UB", frame.substr(0, 2));
+}
+
+TEST(UBShmHandshakeAdapterTest, disabled_hello_requests_tcp_fallback) {
+    brpc::ubring::UBShmHandshakeAdapter adapter;
+    std::string payload;
+    ASSERT_EQ(brpc::handshake::STEP_OK,
+              adapter.BuildHello(false, 0, NULL, &payload));
+    brpc::ubring::HelloMessage decoded{};
+    EXPECT_EQ(brpc::handshake::STEP_FALLBACK,
+              adapter.ParseHello(payload, &decoded));
+    EXPECT_EQ(64, decoded.msg_len);
+}
+
 namespace brpc {
 namespace ubring {
 class UBShmEndpointTest : public ::testing::Test {

From 7b64af537ddf9a0234f7e74bbe605220703712d0 Mon Sep 17 00:00:00 2001
From: Gzure <740684863@qq.com>
Date: Fri, 21 Aug 2026 19:37:00 +0800
Subject: [PATCH 10/11] =?UTF-8?q?handshake=20=E9=80=BB=E8=BE=91=E6=8A=BD?=
 =?UTF-8?q?=E5=8F=96transport=E5=B1=82=EF=BC=8C=E7=94=B1AdapterTransport?=
 =?UTF-8?q?=E7=BB=9F=E4=B8=80=E7=AE=A1=E7=90=86handshake=E5=92=8C=E5=8D=87?=
 =?UTF-8?q?=E7=BA=A7=E5=88=B0rdma/ubshm=E9=80=BB=E8=BE=91?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/cn/handshake_common_design.md            | 1039 ++++++-----------
 docs/cn/urma_proposal.md                      |  527 +++++++++
 src/brpc/adapter_transport.cpp                |  275 ++++-
 src/brpc/adapter_transport.h                  |   18 +-
 src/brpc/handshake/handshake_adapter.cpp      |    4 +-
 src/brpc/handshake/handshake_adapter.h        |    7 +-
 src/brpc/handshake/rdma_handshake.cpp         |   65 +-
 src/brpc/handshake/ubshm_handshake.cpp        |   65 +-
 .../policy/transport_handshake_protocol.cpp   |   20 +-
 src/brpc/rdma/rdma_endpoint.h                 |   18 -
 src/brpc/rdma_transport.cpp                   |  180 +--
 src/brpc/rdma_transport.h                     |   44 +-
 src/brpc/socket.h                             |    4 -
 src/brpc/transport_handshake.cpp              |   84 +-
 src/brpc/transport_handshake.h                |   37 +-
 src/brpc/ubshm/ub_endpoint.h                  |   18 -
 src/brpc/ubshm_transport.cpp                  |  184 +--
 src/brpc/ubshm_transport.h                    |   39 +-
 ...0d20642510e3e3d14a570a041257996772a31.json |    1 +
 ...615a74b896364be016d8a28ec657f714e1422.json |    1 +
 ...ea3f39bb1c3f972074cfdeb983ed964bc1f54.json |    1 +
 ...d4d6ab3654daf64631c4821071a362adf2f1e.json |    1 +
 ...1bdaf944a337cafc10e12152fa2915751f7d0.json |    1 +
 ...705c41b2381b7a5af286fab00d3241d6a5eca.json |    1 +
 ...b8cdaa14683461e3f2562a4ce8dedce8721ed.json |    1 +
 ...7d33a73a6879dca40078e12765880de1061a1.json |    1 +
 ...0956f4dd08aef5a92ffdbffd70a11effd1833.json |    1 +
 ...37defc274c585af039c0e7b995bfe7f0bf804.json |    1 +
 .../urma/graphify-out/cache/stat-index.json   |    1 +
 test/brpc_rdma_unittest.cpp                   |  213 ++--
 test/brpc_transport_handshake_unittest.cpp    |   66 +-
 31 files changed, 1505 insertions(+), 1413 deletions(-)
 create mode 100644 docs/cn/urma_proposal.md
 create mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/01ccfd37e3d64cd110462f1203e0d20642510e3e3d14a570a041257996772a31.json
 create mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/1df09f4812201fd3151eb13e804615a74b896364be016d8a28ec657f714e1422.json
 create mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/3dcbdee4a792ca85149ae0eada9ea3f39bb1c3f972074cfdeb983ed964bc1f54.json
 create mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/5af18e30c1f05aae06e4f45bf09d4d6ab3654daf64631c4821071a362adf2f1e.json
 create mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/608feeb18131c6633a1d3bae5ce1bdaf944a337cafc10e12152fa2915751f7d0.json
 create mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/6870b34881c2bda6a7406307467705c41b2381b7a5af286fab00d3241d6a5eca.json
 create mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/7899e48f9378edf160c448d2d8eb8cdaa14683461e3f2562a4ce8dedce8721ed.json
 create mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/9ead6eae6b7ea7f4b18e3757e1e7d33a73a6879dca40078e12765880de1061a1.json
 create mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/bb7775d86173e02925fc786db010956f4dd08aef5a92ffdbffd70a11effd1833.json
 create mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/f822344e09f50ff082a2ebbaa0f37defc274c585af039c0e7b995bfe7f0bf804.json
 create mode 100644 src/brpc/urma/graphify-out/cache/stat-index.json

diff --git a/docs/cn/handshake_common_design.md b/docs/cn/handshake_common_design.md
index 46501c8a09..169866dc6d 100644
--- a/docs/cn/handshake_common_design.md
+++ b/docs/cn/handshake_common_design.md
@@ -1,840 +1,499 @@
-# RDMA、URMA 与 UBSHM 公共握手组件设计方案
+# RDMA、URMA、UBSHM 公共握手设计（修订版）
 
-## 1. 背景
+## 1. 文档目的
 
-brpc 当前有三种基于 TCP 建立控制连接、再切换到高速数据面的传输：
+本文在现有公共 framing、`HandshakeSession` 和协议字段 adapter 的基础上，进一步明确四个职责边界：
 
-- RDMA：`src/brpc/rdma/rdma_endpoint.*`
-- URMA：`src/brpc/urma/urma_endpoint.*`
-- UBSHM/UBRING：`src/brpc/ubshm/ub_endpoint.*`
+1. `Socket` 只感知一个顶层 `AdapterTransport`，不感知 TCP、RDMA、URMA、UBSHM，也不感知握手 phase。
+2. `AdapterTransport` 自动完成连接升级；升级成功或回退 TCP 后，统一通知 `Socket` 建链完成。
+3. 具体 Transport 只提供握手所需的资源操作接口；握手顺序、状态转换和 fallback 由上层统一编排。
+4. Transport 只负责数据传输和资源生命周期，不负责 TCP 建链、wire framing、握手状态机或握手流程编排。
 
-三套实现都包含以下流程：
+本文只定义架构和迁移方向，不改变 RDMA/URMA/UBSHM 当前 wire format。
 
-```text
-TCP 连接建立
-    -> 发送本地 Hello
-    -> 接收并校验对端 Hello
-    -> 创建或导入高速传输资源
-    -> 返回协商结果/ACK
-    -> 成功切换高速通道，或回退到 TCP
-```
-
-重构前公共流程主要以复制代码的形式存在。例如：
-
-- RDMA 的 TCP 握手读写循环在 `rdma_endpoint.cpp` 中实现；
-- URMA 在 `urma_endpoint.cpp` 中重新实现了一套；
-- UBSHM 在 `ub_endpoint.cpp` 中再次实现了一套；
-- 三套实现都维护独立的握手状态枚举、client/server 流程和 fallback 逻辑。
-
-本方案只抽取握手公共组件，不尝试合并 RDMA QP、URMA Jetty 或 UBSHM ring 的数据面实现。
-
-## 2. 现状分析
-
-### 2.1 RDMA
-
-RDMA 支持：
-
-- v2 二进制握手：`RDMA` magic；
-- v3 protobuf 握手：`RDM3` magic；
-- client/server 两套解析路径；
-- server 侧基于 `butil::IOBuf` 的增量解析；
-- 非 RDMA 连接的 TCP fallback；
-- 4 字节 ACK。
-
-相关代码：
+## 2. 当前问题
 
-- `src/brpc/handshake/handshake_adapter.*`
-- `src/brpc/handshake/rdma_handshake.*`
-- `src/brpc/handshake/rdma_handshake_constants.h`
+现有实现已经抽取了 `HandshakeSession`、`HandshakeCodec` 和公共 framing，但职责仍未完全收敛：
 
-### 2.2 URMA
+- `ProcessHandshakeAtClient` 仍位于具体 Transport 或 endpoint 路径中，client 的握手入口不统一。
+- `RdmaTransport`、`UBShmTransport` 等仍通过各自的 `S_*` 常量暴露握手阶段；`HandshakePhases` 需要填入不同 transport 的 phase，公共 session 无法真正统一。
+- server handshake adapter 需要通过 `Socket` 找到 `AdapterTransport`，再找到具体 Transport，并且直接驱动资源创建、激活和 fallback。
+- `AdapterTransport` 虽然已经是 `Socket` 的顶层对象，但握手的 client/server 入口、连接完成通知和数据面切换仍分散在多个层次。
+- “握手成功”与“Socket 建链完成”不是同一个明确事件，导致 TCP fallback、升级成功和异常退出的发布顺序难以验证。
 
-URMA 的握手结构与 RDMA 类似，但 payload 完全不同：
+根因是把“传输能力”和“建链流程”混在了一起。Transport 是被流程调用的参与者，不应成为流程的拥有者。
 
-- v2 二进制握手：`URMA` magic；
-- v3 protobuf 握手：`URM3` magic；
-- Hello 中携带 EID、UASID、Jetty、segment 和 token 信息；
-- 需要先导入 remote segment，再导入 remote Jetty；
-- 目前 server/client 主要由 `UrmaEndpoint` 自己驱动。
+## 3. 目标架构
 
-相关代码：
-
-- `src/brpc/urma/urma_handshake.h`
-- `src/brpc/urma/urma_handshake.cpp`
-- `src/brpc/urma/urma_endpoint.cpp`
-
-### 2.3 UBSHM/UBRING
-
-UBSHM 当前使用固定长度二进制握手：
+### 3.1 分层
 
 ```text
-[ "UB" 2B ][ HelloMessage 62B ]
+Socket
+  |
+  v
+AdapterTransport                         Socket 唯一感知的 Transport
+  |-- TcpTransport                       TCP 控制面和 fallback 数据面
+  |-- HighSpeedTransport                 RDMA / URMA / UBSHM 数据面
+  |-- ConnectionUpgradeCoordinator       统一的建链与升级编排
+  |     |-- HandshakeSession              公共状态机、I/O、framing
+  |     |-- HandshakeCodec                协议 wire 字段编解码
+  |     |-- TransportUpgradeOps           被调用的资源阶段接口
+  |     `-- SocketConnectionNotifier      建链完成/失败通知
+  `-- ActiveTransport                    根据统一状态选择数据面
 ```
 
-Hello 中携带：
-
-- `msg_len`
-- `hello_ver`
-- `impl_ver`
-- shared memory 长度
-- shared memory 名称
-
-握手成功后，通过 ACK 中的 `UB_OK` bit 表示是否切换到 UBRING；失败时回退 TCP。
-
-相关代码：
-
-- `src/brpc/handshake/ubshm_handshake.*`
-- `src/brpc/ubshm_transport.*`
-- `src/brpc/ubshm/ub_endpoint.*`
-
-## 3. 设计目标
-
-### 3.1 目标
+这里的 `ConnectionUpgradeCoordinator` 可以先作为 `AdapterTransport` 的内部实现，不要求立即新增独立公开类；重要的是职责必须集中在该层，而不是分散到具体 Transport。
 
-1. 消除三套实现中的 TCP 握手读写重复代码。
-2. 统一 magic、长度、版本、ACK、fallback 和错误结果的处理方式。
-3. 支持 client 阻塞式读取和 server 基于 `IOBuf` 的增量读取。
-4. 保持 RDMA、URMA、UBSHM 的现有 wire format 完全兼容。
-5. 让协议 payload 和高速资源协商逻辑继续由各传输实现负责。
-6. 在未开启某一传输宏时，公共组件仍可独立编译。
-
-### 3.2 非目标
-
-本次不抽取以下内容：
-
-- RDMA QP/CQ/PD/MR 创建和销毁；
-- URMA Jetty/JFR/JFC/segment 导入；
-- UBSHM ring 和 shared memory 映射；
-- RDMA、URMA、UBSHM 的数据面 completion 处理；
-- 三种传输的内存池；
-- 三种传输的 poller/CQ 事件线程。
-
-这些组件虽然也存在结构相似性，但资源模型不同，过早抽象会导致公共接口暴露 `ibv_*`、`urma_*` 或 UBRING 类型。
-
-## 4. 总体架构
-
-公共抽象放在 `src/brpc` 的 Transport 层：
+### 3.2 依赖方向
 
 ```text
-src/brpc/
-    adapter_transport.h/.cpp     # Socket 顶层 Transport、TCP-first 路由与状态发布
-    transport_handshake.h/.cpp   # HandshakeSession、codec 与资源阶段编排
-    handshake/handshake_adapter.* # 标准 server parser 适配与 ParseResult 转换
-    handshake/handshake_io.*     # blocking fd I/O 与增量 IOBuf 输入适配
-    handshake/handshake_frame.*  # fixed/U16/U32 通用 framing
-    handshake/rdma_handshake.*   # RDMA v2/v3 字段与 server handshake adapter
-    handshake/ubshm_handshake.*  # UBSHM v2 字段与 server handshake adapter
-    policy/transport_handshake_protocol.* # RDMA/UBSHM server magic 分发
-    rdma_handshake.proto         # RDMA v3 wire message
-    rdma_transport.h/.cpp        # 独立 RDMA Transport、握手回调与数据面
-    ubshm_transport.h/.cpp       # 独立 UBSHM Transport、握手回调与数据面
-```
-
-总体关系如下：
-
-```mermaid
-flowchart TB
-    S["Socket"] --> UT["AdapterTransport\nTCP-first 路由与状态发布"]
-    UT --> TCP["TcpTransport\n默认数据面 / fallback"]
-    UT --> HS["HandshakeSession\ndriver + codec + resource stages"]
-    HS --> IO["SocketHandshakeIO\nReadExact / WriteAll / readable butex"]
-    HS --> FC["FrameCodec\nmagic / length / incremental parse"]
-    UT --> RT["RdmaTransport"]
-    UT --> UTRA["UrmaTransport"]
-    UT --> BT["UBShmTransport"]
-    RT --> RA["RDMA handshake adapter"]
-    BT --> BA["UBSHM handshake adapter"]
-    RT --> RE["RdmaEndpoint\nQP / CQ / MR"]
-    UTRA --> UE["UrmaEndpoint\nJetty / JFC / Segment"]
-    BT --> BE["UBShmEndpoint\nUBRing / Shared Memory"]
-```
-
-`Socket::_transport` 始终指向最上层的 `AdapterTransport`。它组合一个默认 `TcpTransport` 和至多一个独立的 `RdmaTransport`、`UrmaTransport` 或 `UBShmTransport`，并决定当前数据走哪个 Transport。`HandshakeSession` 持有公共 `FrameCodec`，统一 Hello/ACK 的 framing、I/O、状态转换和资源阶段调用；具体协议只通过 callback 编解码 payload 字段并执行被 Session 调度的资源动作。Endpoint 不持有 TCP Transport，也不执行 TCP fd 读写。
-
-## 4.1 选定架构：Handshake 位于 Transport 层
-
-默认先建立 TCP 连接，客户端可以请求升级到 RDMA、URMA 或 UBSHM。握手、升级决策、fallback 和 active transport 选择全部由 `AdapterTransport` 负责。
-
-```mermaid
-flowchart TB
-    Socket["Socket"] --> UT["AdapterTransport\n顶层 Transport"]
-    UT --> TCP["TcpTransport\n默认控制面与 TCP 数据面"]
-    UT --> HS["HandshakeSession\nframing / 字段 codec / 资源阶段 / fallback"]
-    HS --> IO["SocketHandshakeIO"]
-    HS --> FC["FrameCodec"]
-    UT --> T["RdmaTransport / UrmaTransport / UBShmTransport\n独立 Transport"]
-    T --> R["RdmaEndpoint\n仅高速数据面"]
-    T --> U["UrmaEndpoint\n仅高速数据面"]
-    T --> B["UBShmEndpoint\n仅高速数据面"]
-    R --> RD["QP / CQ / MR"]
-    U --> UD["Jetty / JFC / Segment"]
-    B --> BD["UBRing / Shared Memory"]
-    HS -->|"UNINITIALIZED / NEGOTIATING / FALLBACK_TCP"| TCP
-    HS -->|"ESTABLISHED"| T
+Socket -> AdapterTransport -> TcpTransport / HighSpeedTransport
+Socket -> AdapterTransport -> ConnectionUpgradeCoordinator
+ConnectionUpgradeCoordinator -> TransportUpgradeOps
+ConnectionUpgradeCoordinator -> HandshakeSession
+TransportUpgradeOps -> transport-specific endpoint/resource
 ```
 
-RDMA、URMA、UBSHM 仍然是完整的 `Transport` 实现，负责各自的高速发送、等待、事件派发和消息调度；它们不再继承 `AdapterTransport`。在该架构中，Endpoint 不再执行 TCP fd 读写、magic 判断、握手 bthread 或 TCP fallback，只向对应 Transport 提供资源准备、远端参数应用和数据面操作。
+禁止以下反向依赖：
 
-## 4.2 连接升级时序
+- `Socket` 直接调用具体 Transport 或 handshake adapter。
+- `TcpTransport` 调用具体高速度 Transport 的握手函数。
+- `RdmaTransport`、`UrmaTransport`、`UBShmTransport` 调用 `ProcessHandshakeAtClient`、`RunServerHandshake` 等流程函数。
+- 公共 `HandshakeSession` 依赖 `ibv_*`、`urma_*`、UBRING 类型。
+- 具体 Transport 通过自定义 phase 影响 `Socket` 的建链判断。
 
-### 客户端请求高速传输
+## 4. 统一状态模型
 
-```mermaid
-sequenceDiagram
-    participant C as Client
-    participant T as AdapterTransport
-    participant TCP as TcpTransport
-    participant H as HandshakeSession
-    participant E as High-speed Endpoint
-    participant S as Server Transport
-
-    C->>T: Connect()
-    T->>TCP: Establish TCP connection
-    TCP-->>T: TCP connected
-    T->>H: StartClient()
-    H->>TCP: Send high-speed Hello
-    TCP->>S: Hello over TCP
-    S->>S: Select RDMA / URMA / UBSHM provider
-    S-->>TCP: Remote Hello
-    TCP-->>H: Receive Remote Hello
-    H->>E: Parse remote parameters / prepare resources
-    E-->>H: Resource negotiation result
-    alt Upgrade succeeds
-        H->>TCP: Send enabled ACK
-        H->>T: NEGOTIATED
-        T->>E: Activate()
-        T-->>C: Connect done, high-speed active
-    else Upgrade unavailable or resource failure
-        H->>TCP: Send disabled ACK
-        H->>T: FALLBACK
-        T-->>C: Connect done, TCP active
-    end
-```
+### 4.1 握手状态由上层拥有
 
-### 服务端识别客户端请求
-
-```mermaid
-sequenceDiagram
-    participant TCP as TcpTransport
-    participant T as AdapterTransport
-    participant H as HandshakeSession
-    participant E as Selected Endpoint
-    participant IM as InputMessenger
-
-    TCP->>T: TCP readable event
-    T->>T: Peek magic
-    alt Magic matches upgrade protocol
-        T->>H: Create protocol handshake
-        H->>T: Consume Hello frame
-        H->>E: Parse and negotiate resources
-        alt Negotiation succeeds
-            E-->>H: Ready
-            H->>T: Activate endpoint
-            T->>E: Future data events
-        else Negotiation fails
-            H->>T: Fallback to TCP
-            T->>IM: Continue normal TCP parsing
-        end
-    else Magic does not match
-        T->>T: Push back inspected bytes
-        T->>IM: Continue normal TCP parsing
-    end
-```
-
-## 5. 核心接口设计
-
-### 5.1 统一结果类型
+公共状态只描述连接升级流程，不描述某一种资源如何创建：
 
 ```cpp
 namespace brpc {
 namespace handshake {
 
-enum class Role {
-    CLIENT,
-    SERVER,
-};
-
-enum class Result {
-    NEGOTIATED,
-    FALLBACK,
-    NEED_MORE_DATA,
-    IO_ERROR,
-    PROTOCOL_ERROR,
-    RESOURCE_ERROR,
+enum class Phase {
+    kUninitialized,
+    kPreparing,
+    kHelloSending,
+    kHelloWaiting,
+    kNegotiating,
+    kAckSending,
+    kAckWaiting,
+    kEstablished,
+    kFallbackTcp,
+    kFailed,
 };
 
-enum class Phase {
-    INIT,
-    HELLO_SEND,
-    HELLO_WAIT,
-    RESOURCE_NEGOTIATION,
-    ACK_SEND,
-    ACK_WAIT,
-    ESTABLISHED,
-    FALLBACK_TCP,
-    FAILED,
+enum class StepResult {
+    kOk,
+    kFallback,
+    kNeedMore,
+    kNotMine,
+    kError,
 };
 
 }  // namespace handshake
 }  // namespace brpc
 ```
 
-这统一了 RDMA、URMA 与 UBSHM 在字段解析后的成功、fallback、半包和错误结果，也避免协议 adapter 自行推进公共状态。
+`Socket` 和 `AdapterTransport` 只读取 `Phase` 的终态：`kEstablished`、`kFallbackTcp`、`kFailed`。中间状态只由 coordinator/session 使用。
 
-### 5.2 字节流接口
+### 4.2 删除 `HandshakePhases`
 
-握手组件不能直接依赖 `Socket`，否则公共组件会被 brpc endpoint 的私有状态和不同的 server 解析方式绑死。
-
-建议提供两个方向的接口：
+不再使用：
 
 ```cpp
-class HandshakeIO {
-public:
-    virtual ~HandshakeIO() = default;
-
-    // Client 或握手 bthread 使用：必须读满 len 字节。
-    virtual Result ReadExact(void* data, size_t len) = 0;
-
-    // 必须写完全部数据。
-    virtual Result WriteAll(const void* data, size_t len) = 0;
-
-    // 将已经读取但不属于当前握手的数据放回 TCP 输入缓冲区。
-    virtual Result PushBack(const void* data, size_t len) = 0;
-};
-
-class HandshakeInput {
-public:
-    virtual ~HandshakeInput() = default;
-
-    // Server 的 InputMessenger 使用：只查看，不消费。
-    virtual size_t Size() const = 0;
-    virtual bool CopyTo(void* data, size_t len) const = 0;
-
-    // 仅在帧已经完整时消费。
-    virtual bool Consume(size_t len) = 0;
+struct HandshakePhases {
+    int prepare_local;
+    int hello_send;
+    int hello_wait;
+    int negotiate;
+    int ack_send;
+    int ack_wait;
 };
 ```
 
-实现方式：
-
-- client：通过 `SocketHandshakeIO` 统一执行 blocking fd 读写；
-- server：把 `butil::IOBuf` 封装成 `IOBufHandshakeInput`；
-- UBSHM server 与 RDMA 一样使用 `IOBufHandshakeInput`，由 bRPC 标准协议解析流程增量驱动；
-- RDMA 的 `RdmaServerHandshakeAdapter` 直接使用 `HandshakeInput`。
+原因是这些数字并不是协议字段，也不是数据面状态；它们只是历史实现中的日志/状态映射。公共 session 应使用固定的 `Phase`，具体 Transport 的资源子状态留在自身实现中，不向上暴露。
 
-### 5.3 FrameCodec
+例如 RDMA 的 `S_ALLOC_QPCQ`、`S_BRINGUP_QP`、UBSHM 的 `S_ALLOC_SHM` 都只能是具体 Transport 的内部 debug 状态；它们不能再填入公共 `HandshakePhases`，也不能作为 `Socket` 判断建链完成的依据。
 
-FrameCodec 只处理 framing，不理解 RDMA、URMA 或 UBSHM 的业务字段。
+## 5. 模块职责
 
-```cpp
-struct FrameSpec {
-    const char* magic;
-    size_t magic_len;
-    size_t min_frame_len;
-    size_t max_frame_len;
-    enum LengthEncoding {
-        FIXED,
-        U16_TOTAL_LENGTH,
-        U32_BODY_LENGTH,
-    } length_encoding;
-};
+### 5.1 Socket
 
-class FrameCodec {
-public:
-    static FrameResult Encode(const FrameSpec& spec,
-                              const std::string& payload,
-                              std::string* frame);
-    static FrameResult ReadFrame(HandshakeIO* io,
-                            const FrameSpec& spec,
-                            bool push_back_on_not_mine,
-                            std::string* payload);
-    static FrameResult ParseBufferedFrame(HandshakeInput* input,
-                                      const FrameSpec& spec,
-                                      std::string* payload);
-    static FrameResult WriteFrame(HandshakeIO* io,
-                                  const FrameSpec& spec,
-                                  const std::string& payload);
-};
-```
+`Socket` 只保存和调用一个 `Transport*`，实际对象始终为 `AdapterTransport`。它只关心以下事件：
 
-三种协议可以配置为：
+- TCP socket 是否连接成功；
+- `AdapterTransport` 是否报告建链完成；
+- 当前数据面读写是否可用；
+- 连接是否失败或 EOF。
 
-| 传输 | 版本 | Magic | Framing |
-|---|---:|---|---|
-| RDMA | v2 | `RDMA` | U16，总长度 |
-| RDMA | v3 | `RDM3` | U32，body 长度 |
-| URMA | v2 | `URMA` | U16，总长度 |
-| URMA | v3 | `URM3` | U32，body 长度 |
-| UBSHM | v2 | `UB` | 固定长度 64 字节 |
+Socket 不直接读取 handshake phase，也不负责决定 TCP 还是高速度 Transport。
 
-特别注意：`magic_len` 不能固定为 4。UBSHM 使用 2 字节 magic，因此公共组件必须以 `FrameSpec` 为准，而不能复用 RDMA 的 `HELLO_MAGIC_LEN`。
+### 5.2 AdapterTransport
 
-### 5.4 协议适配器
+`AdapterTransport` 是顶层 Transport 和连接升级协调器的宿主，负责：
 
-每个传输提供自己的字段 codec。`HandshakeSession` 持有 codec 描述并负责调用，协议实现只看到去掉 magic/length 后的 payload：
-
-```cpp
-struct HandshakeCodec {
-    int protocol_version;
-    FrameSpec hello_frame;
-    FrameSpec ack_frame;
-    std::function<Result(bool, std::string*)> build_hello;
-    std::function<Result(const std::string&)> parse_hello;
-    std::function<Result(bool, std::string*)> build_ack;
-    std::function<Result(const std::string&, bool*)> parse_ack;
-};
-```
+- 创建并持有 TCP Transport 和候选高速度 Transport；
+- 建立 TCP 控制连接；
+- 自动启动 client/server 的升级编排；
+- 将 TCP 可读事件交给 coordinator，直到升级进入终态；
+- 在 `kEstablished` 与 `kFallbackTcp` 之间选择 active data transport；
+- 对升级结果执行一次性的连接完成通知；
+- 保证 fallback 数据回放和状态发布的内存顺序。
 
-资源动作同样作为回调注册到 Session，但强类型上下文保留在协议 Transport 内：
+建议的内部接口如下：
 
 ```cpp
-struct ClientHandshakeCallbacks {
-    HandshakeCodec codec;
-    std::function<Result()> prepare_resources;
-    std::function<Result()> negotiate_resources;
-};
-```
+class AdapterTransport : public Transport {
+public:
+    std::shared_ptr<AppConnect> Connect() override;
+    void ProcessEvent(bthread_attr_t attr) override;
 
-标准 server parser 通过一个更深的 adapter seam 接入。policy parser 只调用
-`ExecuteServerHandshake`。`StandardHandshakeAdapter` 统一处理 `StepResult` 到
-`ParseResult` 的转换、`ACK_WAIT` parsing context 和终态清理，协议通常只实现
-三个 protected hook；确实无法复用标准 parser 生命周期时，可以直接实现最小
-`HandshakeAdapter` interface：
+    // 由上层 Socket/连接流程使用，不暴露具体 Transport 类型。
+    handshake::Phase connection_phase() const;
 
-```cpp
-class HandshakeAdapter {
-public:
-    virtual ParseResult ExecuteServerHandshake(IOBuf*, Socket*) = 0;
-};
+private:
+    void StartClientUpgrade();
+    void ProcessUpgradeReadable();
+    void CompleteConnection(handshake::Phase terminal_phase);
+    void ActivateTcp();
+    void ActivateHighSpeed();
 
-class StandardHandshakeAdapter : public HandshakeAdapter {
-protected:
-    virtual StepResult RunServerHandshake(IOBuf*, Socket*) = 0;
-    virtual HandshakeSession* GetSession(Socket*) const = 0;
-    virtual int AckWaitPhase(const Socket*) const = 0;
+    handshake::HandshakeSession _handshake;
+    std::unique_ptr<TcpTransport> _tcp_transport;
+    std::unique_ptr<Transport> _high_speed_transport;
+    std::unique_ptr<ConnectionUpgradeCoordinator> _upgrade;
 };
 ```
 
-这样公共头文件不包含 `ibv_*`、`urma_*` 或 UBRING 类型；RDMA 的 `ParsedHello`、URMA 的 Jetty 参数和 UBSHM 的共享内存描述仍由各自 callback 捕获。
+`StartClientUpgrade` 和 `ProcessUpgradeReadable` 是上层编排入口。它们不能下沉到 `RdmaTransport`、`UBShmTransport` 或 endpoint。
 
-## 6. HandshakeSession 状态机
+### 5.3 ConnectionUpgradeCoordinator / HandshakeSession
 
-### 6.1 Client 流程
+该模块拥有连接升级的完整流程：
 
-```text
-INIT
-  -> build_hello
-  -> send_hello
-  -> parse_hello
-  -> parse/validate
-  -> negotiate_resources
-  -> build_ack / send_ack
-  -> ESTABLISHED
-```
+- 选择协议 codec；
+- 通过 TCP 发送和接收 hello/ack；
+- 增量 framing、半包和非本协议数据回放；
+- 按固定顺序调用 Transport 能力接口；
+- 将协议不支持、资源失败转换为 fallback；
+- 发布 `kEstablished`、`kFallbackTcp` 或 `kFailed`；
+- 在终态时通知 `AdapterTransport` 完成建链。
 
-任一步骤发现对端不支持当前高速传输时：
+`HandshakeSession` 不知道 RDMA、URMA、UBSHM 的资源类型，只调用抽象的阶段接口。
 
-```text
-FALLBACK_TCP
-  -> 保留/回放未消费的 TCP 数据
-  -> 交给 InputMessenger/TcpTransport
-```
+### 5.4 具体 Transport
 
-### 6.2 Server 流程
+具体 Transport 只负责：
 
-```text
-UNINIT
-  -> 读取 magic
-  -> 根据 magic/version 选择协议适配器
-  -> 读取完整 Hello
-  -> parse/validate
-  -> negotiate_resources
-  -> send local Hello
-  -> receive client ACK
-  -> ESTABLISHED 或 FALLBACK_TCP
-```
-
-server 解析必须保留 `NEED_MORE_DATA`：
-
-- RDMA/UBSHM 的公共 transport-handshake policy parser 可能多次收到 `IOBuf` 片段；
-- 后续 URMA 接入统一 server parser 时也需要同样行为；
-- 未读完整时不得消费输入缓冲区。
+- 数据面读写、事件和 completion；
+- 资源创建、导入、激活、停用和释放；
+- 提供本端 hello 所需的只读能力/字段；
+- 接收上层解析后的远端参数；
+- 报告资源阶段成功、不可用或失败。
 
-### 6.3 公共驱动与具体资源实现的边界
+具体 Transport 不负责：
 
-`HandshakeSession` 负责资源阶段的进入条件、调用顺序、结果转换和 fallback 发布，但不直接依赖具体资源类型：
+- TCP fd 读写；
+- magic/length framing；
+- hello/ack 的收发顺序；
+- server 增量解析；
+- fallback 决策；
+- `Socket` 建链完成通知；
+- 公共 handshake phase 的推进。
 
-- RDMA：回调中执行 `AllocateResources/BringUpQp`；
-- URMA：回调中执行 `AllocateResources/ImportPeer`；
-- UBSHM：回调中执行 `AllocateClientResources/AllocateServerResources`。
+## 6. Transport 能力接口
 
-也就是说，资源操作被“提到” Session 的状态机中统一编排，具体 `Allocate/Import/BringUp/Map` 实现仍在各 Transport/Endpoint 回调中，从而避免公共组件依赖三种数据面 API。
+Transport 提供的是“被上层调用的资源能力”，不是 handshake driver。建议抽象为以下接口；具体命名可根据现有类调整：
 
-## 7. 三种传输的适配方式
+```cpp
+class TransportUpgradeOps {
+public:
+    virtual ~TransportUpgradeOps() = default;
 
-### 7.1 RDMAAdapter
+    // 返回本端能力和协议 adapter 所需的字段来源。
+    virtual handshake::StepResult PrepareLocal() = 0;
 
-保留：
+    // 上层完成 wire parse/validate 后交付远端参数。
+    virtual handshake::StepResult ApplyRemote(const RemoteParameters&) = 0;
 
-- `ParsedHello`；
-- `HelloMessage` 序列化和反序列化；
-- RDMA v2/v3 protobuf；
-- ECE 校验和 QP 参数处理；
-- `BringUpQp`；
-- RDMA 专属 fallback hello。
+    // 创建、导入或建立数据面资源。
+    virtual handshake::StepResult PrepareResources() = 0;
+    virtual handshake::StepResult NegotiateResources() = 0;
 
-迁移后由 adapter 提供：
+    // 握手 ACK 已发送/确认后切换数据面。
+    virtual handshake::StepResult Activate() = 0;
 
-```text
-BuildHello -> FillLocalRdmaHello
-ParseHello -> ValidRdmaHello + TranslateHello
-Negotiate  -> ApplyRemoteInfo + BringUpQp
-BuildAck   -> RDMA ACK
+    // fallback 或失败时关闭本次升级准备的资源。
+    virtual void Deactivate() = 0;
+};
 ```
 
-### 7.2 URMAAdapter
+说明：
 
-保留：
+- `PrepareLocal`、`ApplyRemote`、`PrepareResources`、`NegotiateResources` 的具体数量可以按现有资源模型合并，但调用顺序由 coordinator 固定。
+- 只有 `TransportUpgradeOps` 的实现可以访问 endpoint 和 transport-specific 类型。
+- 如果某种 Transport 不支持升级，应返回 `kFallback`，而不是创建一套假的握手状态机。
+- `Activate` 成功后，coordinator 才能发布 `kEstablished`。
+- 资源失败默认进入 `kFallbackTcp`；不可恢复的协议错误才进入 `kFailed`，具体策略由 coordinator 统一决定。
 
-- EID/UASID/Jetty/segment/token 字段；
-- URMA v2/v3 protobuf；
-- `ValidHello`；
-- `ImportPeer`；
-- URMA bonding 相关逻辑。
+## 7. 协议 adapter 与公共编排的边界
 
-迁移后由 adapter 提供：
+每一种 wire protocol 保留自己的 `HandshakeCodec` 和字段 adapter：
 
-```text
-BuildHello -> FillLocalHelloV2/FillLocalHelloV3
-ParseHello -> ValidHello + ParsedHello
-Negotiate  -> ApplyRemoteInfo + ImportPeer
-BuildAck   -> URMA ACK
+```cpp
+struct HandshakeCodec {
+    int protocol_version;
+    FrameSpec hello_frame;
+    FrameSpec ack_frame;
+    std::function<StepResult(bool, std::string*)> build_hello;
+    std::function<StepResult(const std::string&)> parse_hello;
+    std::function<StepResult(bool, std::string*)> build_ack;
+    std::function<StepResult(const std::string&, bool*)> parse_ack;
+};
 ```
 
-### 7.3 UBSHMAdapter
+adapter 只处理以下内容：
 
-保留：
+- magic、版本、字段序列化和反序列化；
+- payload 合法性检查；
+- 将字段转换为 `RemoteParameters`；
+- 生成本端 hello 和 ack。
 
-- `HelloMessage`；
-- `HelloMessage::Serialize/Deserialize`；
-- hello/implementation version 校验；
-- shared memory 名称和长度校验；
-- `AllocateClientResources/AllocateServerResources`；
-- `UB_OK` ACK bit。
+adapter 不再实现完整的 `RunServerHandshake` 或 `ProcessHandshakeAtClient`。这些函数中的流程代码应迁移到 coordinator；adapter 只提供 codec 和 `TransportUpgradeOps` 所需的字段转换。
 
-迁移后由 adapter 提供：
+server 端的 `HandshakeAdapter::ExecuteServerHandshake` 如果暂时需要保留以兼容 `InputMessenger`，其实现只能是薄适配层：
 
 ```text
-BuildHello -> 填充 UB HelloMessage
-ParseHello -> 校验 hello_ver/impl_ver/msg_len
-Negotiate  -> 创建或映射 SHM/ring
-BuildAck   -> 4 字节 UB flags
+InputMessenger -> AdapterTransport/Coordinator -> HandshakeSession
+                                      |
+                                      `-> protocol codec + TransportUpgradeOps
 ```
 
-UBSHM 是最适合优先迁移的实现，因为它只有固定长度 v2 协议，不涉及 protobuf 和多版本 frame dispatch。
-
-## 8. 与现有 Endpoint 的关系
-
-不建议让 `RdmaEndpoint`、`UrmaEndpoint`、`UBShmEndpoint` 继承一个包含大量虚函数的“大 Endpoint 基类”。握手组件组合在 Transport 层，Endpoint 只暴露资源接口：
-
-```cpp
-class AdapterTransport : public Transport {
-    handshake::HandshakeSession _handshake;
-    std::unique_ptr<TcpTransport> _tcp_transport;
-    std::unique_ptr<Transport> _high_speed_transport;
-};
-
-class RdmaTransport : public Transport {
-    RdmaEndpoint* _endpoint;
-    // client 每次升级尝试创建字段 adapter；server 由公共 adapter 驱动。
-};
+它不应再根据 `SocketMode` 选择不同的 phase，也不应直接调用具体 Transport 的握手流程。
 
-class UrmaTransport : public Transport {
-    UrmaEndpoint* _endpoint;
-    // 每次升级尝试创建一个 UrmaHandshakeAdapter。
-};
-
-class UBShmTransport : public Transport {
-    UBShmEndpoint* _endpoint;
-    // 每次升级尝试创建一个 UBShmHandshakeAdapter。
-};
+## 8. Client 建链时序
 
-class RdmaEndpoint {
-    RdmaResource* _resource;
-    // QP/CQ/MR and data path only.
-};
+```mermaid
+sequenceDiagram
+    participant S as Socket
+    participant A as AdapterTransport
+    participant C as Coordinator
+    participant T as TcpTransport
+    participant H as HandshakeSession
+    participant U as TransportUpgradeOps
+
+    S->>A: Connect()
+    A->>T: 建立 TCP 控制连接
+    T-->>A: TCP connected
+    A->>C: StartClientUpgrade()
+    C->>U: PrepareLocal()
+    C->>H: 发送 local hello
+    H->>T: WriteFrame()
+    T-->>H: 接收 remote hello
+    C->>U: ApplyRemote() / PrepareResources()
+    C->>U: NegotiateResources()
+    alt 升级成功
+        C->>H: 发送 enabled ACK
+        C->>U: Activate()
+        C->>A: kEstablished
+        A->>S: ConnectionReady(high-speed)
+    else 对端不支持或资源失败
+        C->>H: 发送 disabled ACK（如协议要求）
+        C->>U: Deactivate()
+        C->>A: kFallbackTcp
+        A->>S: ConnectionReady(tcp)
+    end
 ```
 
-Endpoint 仍然拥有：
+关键约束：`ConnectionReady` 只发送一次，并且必须发生在 active transport 已设置、fallback 缓冲区已回放、终态已 release-store 之后。
 
-- Socket；
-- transport-specific resource；
-- endpoint state 的业务动作；
-- data path；
-- transport-specific error handling。
+## 9. Server 建链时序
 
-`AdapterTransport` 拥有 TCP 路由、公共握手阶段和 active Transport 选择；`HandshakeSession` 拥有 framing/codec/资源阶段编排；具体高速 Transport 提供字段与资源 callback 并管理 Endpoint 生命周期。公共 driver 不直接依赖 Endpoint 类型。
+server 收到 TCP 数据后，由 `AdapterTransport` 的上层 coordinator 处理；具体 Transport 不参与入口选择：
 
-## 9. 兼容性和安全约束
-
-### 9.1 Wire compatibility
-
-重构前后必须保持：
-
-- magic 不变；
-- v2/v3 版本号不变；
-- 长度字段的字节序和语义不变；
-- ACK 长度和 bit 定义不变；
-- fallback hello 的无效字段规则不变；
-- RDMA/URMA/UBSHM 之间不能误识别 magic。
+```text
+TCP readable
+  -> AdapterTransport::ProcessUpgradeReadable
+  -> HandshakeSession::RunServer(input)
+  -> 根据 magic 选择 codec
+  -> 增量读取完整 hello
+  -> codec parse/validate
+  -> TransportUpgradeOps::ApplyRemote/NegotiateResources
+  -> 发送 ACK
+  -> Activate 或 Deactivate
+  -> AdapterTransport::CompleteConnection
+```
 
-### 9.2 长度校验
+对于 `IOBuf` 增量输入：
 
-FrameCodec 必须统一执行：
+- `kNeedMore` 时不得消费不完整 frame；
+- magic 不匹配时必须把已检查的数据回放给 TCP parser；
+- 已确认属于升级协议但资源失败时不能把完整握手 frame 当作普通 TCP 数据；
+- ACK 没有 magic 时，选中的 codec 必须保存在 coordinator/session context 中，而不能依赖重新探测。
 
-- 最小帧长度检查；
-- 最大帧长度限制；
-- 整数溢出检查；
-- 长度字段是否包含 magic 的明确配置；
-- protobuf body 长度限制；
-- 固定长度协议的精确长度检查。
+## 10. 连接终态与 Socket 通知
 
-### 9.3 fallback 数据处理
+### 10.1 终态定义
 
-当 magic 不匹配时：
+| 终态 | active data transport | Socket 结果 | 说明 |
+|---|---|---|---|
+| `kEstablished` | 高速度 Transport | 建链完成 | `Activate()` 成功后发布 |
+| `kFallbackTcp` | TCP Transport | 建链完成 | 协议不支持或资源不可用 |
+| `kFailed` | 无 | 建链失败 | I/O、协议或不可恢复错误 |
 
-- client 侧按现有协议处理错误或回退；
-- server 侧必须将已经读取的 magic 放回 `_read_buf`，再交给 TCP parser；
-- 任何已经确认属于高速协议的完整帧，不能直接交给普通 TCP parser。
+`kFallbackTcp` 不是失败。它表示控制连接成功且连接可继续使用 TCP。
 
-### 9.4 资源失败
+### 10.2 发布顺序
 
-协议格式正确不代表高速传输一定可用：
+统一采用以下顺序：
 
 ```text
-Hello valid
-    -> resource allocation/import failed
-    -> send non-negotiable hello or disabled ACK
-    -> fallback TCP
+1. 设置 active transport
+2. 回放 fallback 时已读但不属于握手的数据（仅 TCP fallback）
+3. 发布终态 phase（release）
+4. 通知 Socket::ConnectionReady / ConnectionFailed
 ```
 
-因此 `ParseHello` 和 `Negotiate` 必须保持两个独立步骤。
-
-## 10. 测试方案
-
-### 10.1 公共组件单元测试
-
-覆盖：
-
-- magic 长度为 2 和 4；
-- fixed/U16/U32 三种 framing；
-- 半包读取；
-- 多余数据 drain；
-- 最大长度和最小长度；
-- 长度字段溢出；
-- magic 不匹配并 push-back；
-- `NEED_MORE_DATA` 时不消费输入 buffer；
-- IO error、EOF、超时。
+事件线程观察到终态后，才能读取 active transport 和回放数据。禁止在 phase 发布后再修改 active transport。
 
-### 10.2 协议适配器测试
+### 10.3 TCP 数据保护
 
-分别测试：
+进入 `kEstablished` 后，TCP 只作为控制连接存在；如果收到额外 TCP 应用数据，应按协议错误处理，不能静默交给高速度数据面。进入 `kFallbackTcp` 后，后续数据全部交给 TCP Transport。
 
-- RDMA v2/v3 hello；
-- URMA v2/v3 hello；
-- UBSHM v2 hello；
-- invalid hello fallback；
-- ACK enabled/disabled；
-- resource negotiation failure。
+## 11. 现有实现迁移方案
 
-### 10.3 兼容性测试
+### Phase 1：统一公共状态
 
-至少保留以下组合：
+- 用 `handshake::Phase` 替换 `HandshakePhases` 的六个 transport-specific 数值。
+- `HandshakeSession` 只写入统一 phase。
+- 保留具体 Transport 内部状态用于日志和资源调试，但不再通过 `handshake_phase()` 暴露给 Socket。
 
-| Client | Server | 预期 |
-|---|---|---|
-| RDMA v2 | RDMA v2 | RDMA |
-| RDMA v3 | RDMA v3 | RDMA |
-| URMA v2 | URMA v2 | URMA |
-| URMA v3 | URMA v3 | URMA |
-| UBSHM | UBSHM | UBSHM |
-| 高速 client | TCP server | TCP fallback |
-| TCP client | 高速 server | TCP fallback |
-| 高速资源失败 | 高速对端 | TCP fallback |
+### Phase 2：收拢 client 入口
 
-## 11. 分阶段实施计划
+- 将所有 `ProcessHandshakeAtClient` 的调用点迁移到 `AdapterTransport::StartClientUpgrade`。
+- 删除具体 Transport 中的 client handshake driver。
+- 具体 Transport 改为实现 `TransportUpgradeOps`，只提供资源阶段操作。
+- `AdapterTransport::Connect` 在 TCP connected 后自动启动 coordinator。
 
-### Phase 0：建立行为基线
+### Phase 3：收拢 server 入口
 
-- **已完成（受控源码）**：为公共状态机补齐成功、资源失败、fallback、增量 ACK 等单元测试；
-- **已完成**：RDMA v2/v3 与 UBSHM v2 的既有兼容性测试继续固化 wire format；
-- **已完成**：记录状态转换、半包不消费和 fallback 发布顺序；
-- **URMA 待其源码合入**：复用同一组 framing/driver 测试模板补齐 v2/v3 样例。
+- `InputMessenger` 只把 handshake 输入交给 `AdapterTransport`/coordinator。
+- `RdmaServerHandshakeAdapter`、`UBShmServerHandshakeAdapter` 等降级为 codec/字段 adapter 或薄兼容层。
+- 删除 adapter 内按 `SocketMode` 选择 `S_ACK_WAIT` 等 phase 的逻辑。
+- URMA 接入时直接实现统一的 codec 和 `TransportUpgradeOps`，不复制一套 server driver。
 
-### Phase 1：抽取公共 I/O 和 framing
+### Phase 4：统一连接完成通知
 
-- **已完成**：新增 `src/brpc/handshake/handshake_io.*`；
-- **已完成**：新增 `src/brpc/handshake/handshake_frame.*`；
-- **已完成**：迁移 UBSHM 固定长度握手；
-- **URMA 待其源码合入**：使用 `U16_TOTAL_LENGTH/U32_BODY_LENGTH` 迁移 v2/v3；
-- **已完成**：迁移 RDMA v2/v3，协议 adapter 只解析 payload 字段。
+- 为 `AdapterTransport` 增加单一的 `CompleteConnection` 路径。
+- 升级成功、TCP fallback、失败分别通过统一终态通知 Socket。
+- 增加断言，确保 `ConnectionReady` 只发生一次，且发生在终态发布之后。
 
-### Phase 2：抽取公共 driver
+### Phase 5：删除旧路径
 
-- **已完成**：引入统一 `FrameResult/StepResult/Phase`；
-- **已完成**：client/server 的 framing、codec 调用和握手阶段迁移到 `HandshakeSession`；
-- **已完成**：Session 统一编排资源回调，Endpoint 保留强类型资源实现；
-- **已完成**：统一 fallback、错误处理和 established 发布顺序。
+- 删除具体 Transport 的 `ProcessHandshakeAtClient`、`RunServerHandshake` 和握手 phase 映射。
+- 删除 Socket 对具体 Transport 类型和 transport-specific phase 的依赖。
+- 清理只为旧握手路径存在的 endpoint 回调。
 
-### Phase 3：清理旧实现
+## 12. 兼容性与测试要求
 
-- **已完成（RDMA/UBSHM）**：删除 Endpoint 中重复的握手 fd 读写；client 统一使用 `SocketHandshakeIO`，server 统一使用 `IOBufHandshakeInput`；
-- **已完成（RDMA/UBSHM）**：删除可替代的 magic/length 解析，统一使用 `FrameCodec`；
-- **已完成**：仅保留各协议的 payload 字段 codec 和资源回调；
-- **已完成**：CMake/Bazel 通过递归 glob 收录，Makefile 增加 `src/brpc/handshake`，并更新公共测试；
-- **URMA 待其源码合入**：删除 Endpoint 中对应旧握手实现。
+### 12.1 Wire compatibility
 
-## 12. 主要风险和规避方式
+重构不得改变：
 
-### 风险一：公共抽象过度绑定 Socket
+- RDMA v2/v3、URMA v2/v3、UBSHM v2 的 magic；
+- frame length 的字节序和语义；
+- hello/ack 的字段布局和 ACK bit；
+- fallback hello 的兼容行为。
 
-规避：状态发布和协议 adapter 不依赖 Endpoint；纯虚 `HandshakeIO` 隔离字节流，只有 `SocketHandshakeIO` 持有 non-owning `Socket*` 并集中封装 fd 等待与读写，单测可直接注入内存实现。
+### 12.2 公共模块测试
 
-### 风险二：混淆不同长度字段语义
+至少覆盖：
 
-RDMA/URMA/UBSHM 的长度字段并不完全相同。规避：使用 `FrameSpec::LengthEncoding`，并在每个协议 adapter 中明确配置。
+- 2 字节和 4 字节 magic；
+- fixed、U16 total length、U32 body length；
+- 半包、粘包和多余数据；
+- `kNeedMore` 不消费不完整输入；
+- magic 不匹配的 push-back；
+- I/O error、EOF、超时和协议错误；
+- 终态发布顺序和一次性连接通知。
 
-### 风险三：server 增量解析行为改变
+### 12.3 集成矩阵
 
-规避：公共 `ParseBufferedFrame` 在完整帧可用前只返回 `NEED_MORE_DATA`，不消费任何数据。
+| 场景 | 预期结果 |
+|---|---|
+| RDMA v2 ↔ RDMA v2 | 高速度 Transport 建链 |
+| RDMA v3 ↔ RDMA v3 | 高速度 Transport 建链 |
+| URMA v2/v3 ↔ 对应版本 | 高速度 Transport 建链 |
+| UBSHM ↔ UBSHM | UBSHM 建链 |
+| 高速度 client ↔ TCP server | TCP fallback，Socket 建链成功 |
+| TCP client ↔ 高速度 server | TCP 建链成功 |
+| hello 合法但资源创建失败 | TCP fallback |
+| 已识别握手协议后发生协议错误 | 建链失败，不回放为 TCP 数据 |
 
-### 风险四：握手成功后资源失败被误认为协议失败
+## 13. 验收标准
 
-规避：将 `ParseHello` 与 `Negotiate` 分离，资源失败统一转换成可配置的 fallback 行为。
+设计落地后应满足：
 
-### 风险五：UBSHM 的 2 字节 magic 被 4 字节假设破坏
+1. `Socket::_transport` 永远只指向 `AdapterTransport`，Socket 源码中没有具体 Transport 类型判断。
+2. client 和 server 都只有一个握手编排入口，代码库中不再存在具体 Transport 的 `ProcessHandshakeAtClient`。
+3. 公共握手状态只有一套 `handshake::Phase`，不存在 RDMA/UBSHM/URMA 到公共 phase 的数字映射。
+4. 具体 Transport 不读写 TCP fd，不解析 magic/length，不调用 `HandshakeSession::RunClient/RunServer`。
+5. 升级成功和 TCP fallback 都由 `AdapterTransport` 自动完成 active transport 切换，并向 Socket 发出一次建链完成通知。
+6. 在 wire compatibility 测试通过的前提下，握手流程、fallback 和连接完成通知可以通过公共 coordinator 单元测试验证。
 
-规避：所有 magic 操作都依赖 `FrameSpec.magic_len`，禁止公共代码写死 4。
+## 14. 结论
 
-## 13. 结论
-
-建议抽取的公共组件边界是：
+最终边界如下：
 
 ```text
-公共：TCP 握手 I/O、frame framing、magic/length、增量解析、状态驱动、ACK/fallback 结果
-私有：Hello payload、版本语义、具体 QP/Jetty/SHM 资源操作、数据面 completion
-```
+Socket
+  只感知 AdapterTransport 和 ConnectionReady
 
-实施上以当前 RDMA 握手状态机为基线：先保留 #3350 已接入的标准 server 协议解析流程，再迁移 UBSHM，最后在 URMA 分支重新基于公共接口适配。这样可以直接继承已经过社区修复和测试的 fallback 语义。
+AdapterTransport / Coordinator
+  拥有 TCP-first、握手状态机、升级/fallback 编排、active transport 切换
 
-## 14. 当前实现边界与后续迁移
+HandshakeSession / Codec
+  拥有公共 I/O、framing、协议字段编解码和统一状态
 
-当前实现已经引入 `AdapterTransport` 和 `HandshakeSession`，类关系如下：
+TransportUpgradeOps
+  提供具体传输所需的资源阶段接口
 
-```mermaid
-classDiagram
-    class Transport
-    class TcpTransport
-    class AdapterTransport {
-        -HandshakeSession handshake
-        -TcpTransport tcp_transport
-        -Transport high_speed_transport
-        +CutFromIOBuf()
-        +CutFromIOBufList()
-        +WaitEpollOut()
-        +FallbackToTcp()
-    }
-    class HandshakeSession {
-        -SocketHandshakeIO io
-        -FrameCodec frame_codec
-        -atomic phase
-        -int protocol_version
-        +RunClient(callbacks)
-        +RunServer(callbacks)
-        +MarkEstablished()
-        +PublishFallback()
-        +MarkFailed()
-    }
-    class RdmaTransport
-    class HandshakeAdapter
-    class StandardHandshakeAdapter
-    class RdmaServerHandshakeAdapter
-    class RdmaHandshakeAdapter
-    class UBShmServerHandshakeAdapter
-    class UBShmHandshakeAdapter
-    class HandshakeCodec
-    class FrameCodec
-    class UrmaTransport
-    class UBShmTransport
-    class HighSpeedEndpoint
-
-    Transport <|-- TcpTransport
-    Transport <|-- AdapterTransport
-    Transport <|-- RdmaTransport
-    Transport <|-- UrmaTransport
-    Transport <|-- UBShmTransport
-    AdapterTransport *-- TcpTransport
-    AdapterTransport *-- RdmaTransport
-    AdapterTransport *-- UrmaTransport
-    AdapterTransport *-- UBShmTransport
-    AdapterTransport *-- HandshakeSession
-    HandshakeSession *-- SocketHandshakeIO
-    HandshakeSession --> FrameCodec
-    HandshakeSession o-- HandshakeCodec
-    HandshakeAdapter <|-- StandardHandshakeAdapter
-    StandardHandshakeAdapter <|-- RdmaServerHandshakeAdapter
-    StandardHandshakeAdapter <|-- UBShmServerHandshakeAdapter
-    RdmaServerHandshakeAdapter --> HandshakeSession
-    RdmaServerHandshakeAdapter --> RdmaHandshakeAdapter
-    UBShmServerHandshakeAdapter --> HandshakeSession
-    UBShmServerHandshakeAdapter --> UBShmHandshakeAdapter
-    RdmaTransport --> RdmaHandshakeAdapter
-    UBShmTransport --> UBShmHandshakeAdapter
-    RdmaTransport --> HighSpeedEndpoint
-    UBShmTransport --> HighSpeedEndpoint
+RDMA / URMA / UBSHM Transport
+  只拥有各自资源、数据面和 completion
 ```
 
-`AdapterTransport` 是安装在 `Socket` 上的最上层 TCP-first Transport：`UNINITIALIZED/NEGOTIATING/FALLBACK_TCP` 都委托给 `TcpTransport`，仅当 `HandshakeSession` release 发布 `ESTABLISHED` 后才委托给所选的 RDMA/URMA/UBSHM Transport。成功升级后的 TCP 控制连接只允许 EOF，不再接受应用数据。
-
-`HandshakeSession::RunClient/RunServer` 持有 `HandshakeCodec` 并统一执行 framing、Hello/ACK 收发、字段 codec 调用、资源准备/协商回调以及 established/fallback/failed 发布。`StandardHandshakeAdapter::ExecuteServerHandshake` 统一桥接 bRPC 标准 parser；`RdmaServerHandshakeAdapter` 和 `UBShmServerHandshakeAdapter` 分别组装真实高速连接或 plain-TCP fallback callback。公共 `transport_handshake` policy 根据 magic 分发首次 Hello，并在 parsing context 中保留选中的 adapter，确保后续无 magic 的 ACK 仍回到同一状态机。注册时暂时保留既有 `PROTOCOL_RDMA_HANDSHAKE` 数值和 `rdma_handshake` 名称，避免破坏兼容性。RDMA/UBSHM server 都由标准 parser 增量驱动。
+一句话概括：**握手是上层连接编排，Transport 是被编排的数据传输能力；Socket 只通过 AdapterTransport 观察连接结果。**
+## 15. 整体架构图
 
-### 14.1 当前完成度
-
-| 项目 | 状态 | 说明 |
-|---|---|---|
-| TCP-first 路由 | 已实现 | `Socket` 持有顶层 `AdapterTransport`；其组合 `TcpTransport` 和一个独立高速 `Transport` |
-| 公共握手处理 | 已实现 | `RunClient/RunServer` 统一 FrameCodec、字段 codec、资源回调、ACK、fallback 和错误流程 |
-| RDMA client/server | 已迁移 | adapter、wire 常量和 server executor 位于 `src/brpc/handshake`；真实 RDMA 与无 RDMA Endpoint 的 fallback 共用 `HandshakeAdapter/Session`；server 保留 #3350 的标准增量解析流程 |
-| UBSHM client/server | 已迁移 | 字段 codec、固定 64 字节 framing、2 字节 magic、ACK 与 server executor 位于 `src/brpc/handshake`；client 由 `UBShmTransport` 驱动，server 与 RDMA 一样走标准增量 parser |
-| URMA | 待迁移 | origin/master 暂无受版本控制的 URMA Transport；合入后保留独立 `UrmaTransport`，由顶层 `AdapterTransport` 组合并复用 `HandshakeSession` |
-| RDMA Protocol adapter | 已实现 | `RdmaHandshakeAdapter` 只构造/解析 v2/v3 payload 字段，不再读写 fd 或消费 `IOBuf` |
-| Server parser adapter | 已实现 | `HandshakeAdapter` 抽象唯一入口；`StandardHandshakeAdapter` 统一 ParseResult、ACK_WAIT context 和清理流程；公共 policy 分发 RDMA/UBSHM，协议只实现 driver hook |
-| 通用 FrameCodec | 已实现 | 支持 fixed、U16 总长度、U32 body 长度、2/4 字节 magic、blocking I/O 和增量 `IOBuf` 解析 |
-
-### 14.2 必须继承的修复语义
-
-| 修复 | 公共约束 | 落点 |
-|---|---|---|
-| #3347 | fallback 状态必须原子发布，事件线程用 acquire 读取 | `HandshakeSession::PublishFallback/phase` |
-| #3406 | 必须先发布 Transport 的 TCP active/off 状态，再 release 发布 `FALLBACK_TCP` | `HandshakeSession` 先调用 `set_tcp_active` callback，再 release 发布终态 |
-| #3424 | 高速资源准备失败是可降级错误；清理部分资源并保持 TCP 可用 | RDMA 保留事务式 `AllocateResources`；失败后由公共 fallback 路径恢复 TCP |
-| #3425 | CQ re-arm 后同时补 poll send/recv CQ | 保留在 RDMA Endpoint 数据面，不移入握手组件 |
-| #3427 | 外部 Bazel workspace 下生成规则不能依赖主仓布局 | 公共实现不新增 proto；源码通过现有递归 glob 收录 |
-| server 同包 Hello/ACK | parser 只消费当前 Hello frame，不能清空后续 ACK/RPC；发送 Hello 后立即尝试解析已到达的 ACK | RDMA adapter 按声明长度消费扩展字段；`HandshakeSession::RunServer` 和 fallback parser 不强制等待下一次读事件 |
-
-### 14.3 状态发布规则
-
-成功升级和回退由 `HandshakeSession` 按固定顺序发布，Transport callback 只切换 provider 状态：
-
-```cpp
-// Fallback: publish TCP/provider state first, then terminal phase.
-PublishFallback([&callbacks]() {
-    callbacks.set_tcp_active();
-});
-
-// Success: endpoint is ready before ESTABLISHED becomes visible.
-callbacks.set_high_speed_active();
-MarkEstablished();
+```mermaid
+flowchart TB
+    S["Socket\n只感知 AdapterTransport"]
+    A["AdapterTransport\nTCP-first / 建链编排 / active transport"]
+    C["Connection Upgrade Coordinator\nStartClientUpgrade / ProcessUpgradeReadable\nCompleteConnection"]
+    H["HandshakeSession\n统一 framing / I/O / handshake::Phase"]
+    RA["Protocol Codec Adapter\nRDMA v2/v3 / URMA / UBSHM"]
+    O["TransportUpgradeOps\nPrepare / Negotiate / Activate / Deactivate"]
+    T["Concrete Transport\nTCP / RDMA / URMA / UBSHM"]
+    E["Endpoint / Resource\n只提供传输资源能力"]
+    IM["InputMessenger\nserver 增量输入"]
+    READY["ConnectionReady\nESTABLISHED / FALLBACK_TCP"]
+    FAIL["ConnectionFailed\nFAILED"]
+
+    S -->|Connect| A
+    A -->|TCP connected| C
+    IM -->|ProcessUpgradeReadable| A
+    A --> C
+    C <--> H
+    C --> RA
+    C --> O
+    O --> T
+    T --> E
+    C -->|terminal phase| A
+    A --> READY
+    A --> FAIL
 ```
 
-事件线程必须通过 acquire load 读取 phase。看到 `FALLBACK_TCP` 后可以直接恢复 `InputMessenger`；看到 `ESTABLISHED` 后才允许发送和接收高速数据。`UNINITIALIZED/NEGOTIATING` 状态不得路由到 Endpoint 数据面。
+核心边界：`HandshakeSession` 负责公共握手流程，协议 Adapter 只负责 wire codec，`TransportUpgradeOps` 只负责资源能力；具体 Transport 不读取握手输入、不编排握手阶段，也不向 Socket 暴露 transport-specific phase。
diff --git a/docs/cn/urma_proposal.md b/docs/cn/urma_proposal.md
new file mode 100644
index 0000000000..f41484e105
--- /dev/null
+++ b/docs/cn/urma_proposal.md
@@ -0,0 +1,527 @@
+# UrmaTransport 提案：基于 openEuler URMA 的远程内存语义传输层
+
+> 关联讨论：
+> - [#3167 brpc支持传输层多协议改进建议](https://github.com/apache/brpc/issues/3167) —— Socket-Transport 架构改造共识
+> - [#3217 openEuler总线协议 urma 和 obmm 技术路线讨论](https://github.com/apache/brpc/discussions/3217) —— 路线 B（URMA-UrmaTransport）与路线 C（双后端）共识
+> - [#3226 基于UB协议OBMM共享内存Transport方案设计](https://github.com/apache/brpc/issues/3226) —— OBMM/ShmTransport 实现方案
+>
+> 本提案对应 #3217 中的**路线 B**，并与 #3226 的 OBMM-ShmTransport 形成**路线 C（双后端协同）**。
+
+## 1. 背景与动机
+
+### 1.1 现有传输层的局限
+
+brpc 当前内置三种传输层（`SOCKET_MODE_TCP` / `SOCKET_MODE_RDMA` / `SOCKET_MODE_UBRING`），均通过 #3167 落地的 `Transport` 抽象接入：
+
+| 传输层 | 访问语义 | 单跳延迟 | 连接模型 | 适用场景 |
+|--------|----------|----------|----------|----------|
+| TCP | Socket API（字节流） | ~50μs | 5-tuple | 广域网/局域网 |
+| RDMA | Verbs API（异步） | ~2-5μs | RC-QP（每连接一个 QP） | 数据中心，`baidu_std` 协议 |
+| UBRing | Load/Store（共享内存） | ~500ns | 共享内存环 | 同机 IPC / UBS-Mem 跨节点 |
+
+三者各有边界，但在以下场景仍存在缺口：
+
+1. **RDMA 的 QP 爆炸**：RC 模型下每条逻辑连接占用一个 QP，千级节点规模下 QP 数量达百万级，耗尽网卡片上 SRAM，触发 QP 状态 Cache Miss，延迟从 ~12μs 跳变至 ~300μs。
+2. **RDMA 的控制面/数据面资源争用**：内存注册/注销与数据面竞争网卡内部资源，高并发下性能抖动。
+3. **RDMA 编程模型笨重**：`准备 WQE → Doorbell → 轮询 CQE` 的异步流程在小包（数百字节）场景下，WQE 构建开销占比可达 17.8%。
+4. **UBRing 的跨节点能力受限**：当前跨节点依赖 UBS-Mem（`ub_shm_type=2`），需要额外 `libubsm_sdk.so`；其 64 字节定长分块（60B payload + 4B header）对大包不友好，单消息上限受 `data_queue_size` 约束（超限返回 `EMSGSIZE`）。
+5. **大包/小包协同缺失**：UBRing 对小包极优（亚微秒、零系统调用），但大包要切分成 ~17k 个 64 字节块逐块拷贝；RDMA 对大包友好（直接 SGE 零拷贝），但小包开销高。目前两者各自独立，无法在一个连接内按包大小自动选择最优路径。
+
+### 1.2 URMA 是什么
+
+[URMA（Unified Remote Memory Access）](https://atomgit.com/openeuler/umdk)是 openEuler 在 UB（Unified Bus）总线上提供的用户态远程内存访问 SDK，核心特性：
+
+- **无连接 UM（Unreliable Datagram）语义**：驱动内置重传/CRC，可靠且免 RC-QP 爆炸——**单 Jetty 可打 N 个远端**，连接数为 O(N) 而非 O(N×线程数)。
+- **统一内存操作语义**：单边（`URMA_OP_SEND`/`URMA_OP_READ`/`URMA_OP_WRITE`）、双边、原子操作通过同一套 `urma_post_send/recv` API 实现，**RoCE v2 / InfiniBand / PCIe P2P 三种底层统一对接**。
+- **URMA-SHM 模式**：远端映射同一物理页，本机与跨机共享内存统一访问，天然适配 `one2all` 场景。
+- **Jetty 流控**：硬件级流控替代 RDMA 的 PFC/ECN，避免拥塞丢包。
+
+性能定位（引用 #3217 实测口径）：
+
+| 技术方案 | 访问方式 | 单跳延迟 | 编程模型 | 缓存一致性 | 适用边界 |
+|----------|----------|----------|----------|------------|----------|
+| RDMA | Verbs API（异步） | ~2-5μs | Read/Write/Send | 无（需软件同步） | 数据中心 |
+| URMA | Segment API（异步） | ~2-5μs | Read/Write | 可选硬件一致性 | 超节点 |
+| OBMM | Load/Store | ~几百ns | 直接内存访问 | 可选 NC 和 CC 两种 | 超节点 |
+
+### 1.3 本提案的目标
+
+**面向超节点（UB 总线互联的 CPU/GPU 集群）场景，新增一个 UrmaTransport，作为 RDMA 在 UB 场景的对等替代与升级**：
+
+1. **性能对标 RDMA**：在 RoCE/IB 底层上达到与现有 `RdmaTransport` 同量级延迟（~2-5μs），并通过 UM 语义消除 QP 爆炸。
+2. **与 UBSHMTransport 大小包协同**：复用 #3226 的 OBMM-ShmTransport 小包极速路径，由 UrmaTransport 承接大包/跨节点高吞吐路径，运行时按包大小与拓扑自动选择（路线 C）。
+3. **复用现有 Transport 框架**：完全沿用 #3167 落地的 `Transport` / `TransportFactory` / `SocketMode` 抽象，不侵入 `Socket`/`InputMessenger`/协议层。
+4. **平滑落地**：参考 `RdmaTransport` 的「compose TcpTransport + tri-state 协商 + TCP fallback」模式，保证未启用/对端不支持时透明回退 TCP。
+
+## 2. 总体架构
+
+### 2.1 在 brpc 中的位置
+
+```mermaid
+flowchart TD
+    subgraph UserAPI["用户接口层"]
+        CS["Channel / Server<br/>ChannelOptions / ServerOptions<br/>socket_mode = SOCKET_MODE_URMA"]
+    end
+    subgraph Factory["TransportFactory (transport_factory.{h,cpp})"]
+        F["if/else-if on SocketMode<br/>TCP → TcpTransport<br/>RDMA → RdmaTransport #if BRPC_WITH_RDMA<br/>UBRING → UBShmTransport #if BRPC_WITH_UBRING<br/>URMA → UrmaTransport #if BRPC_WITH_URMA ★新增"]
+    end
+    subgraph UrmaTransportLayer["UrmaTransport : public Transport (urma_transport.{h,cpp})"]
+        T["std::shared_ptr&lt;TcpTransport&gt; _tcp_transport (fallback)<br/>urma::UrmaEndpoint* _urma_ep<br/>UrmaState _urma_state {ON / OFF / UNKNOWN}"]
+    end
+    subgraph UrmaEndpointLayer["urma::UrmaEndpoint : public SocketUser (urma/urma_endpoint.*)"]
+        E["Jetty / URMA Segment 管理<br/>建链握手状态机（C/S 对称）<br/>数据收发：urma_post_send / urma_post_recv / CQ 轮询<br/>大小包分流：与小包 ShmTransport 协同"]
+    end
+    CS -->|"ContextInitOrDie(mode, ...)<br/>CreateTransport(mode)"| F
+    F --> T
+    T --> E
+```
+
+UrmaTransport 与 `RdmaTransport`、`UBShmTransport` 并列为第四种 `Transport` 实现，对外行为完全一致：用户只需把 `socket_mode` 设为 `SOCKET_MODE_URMA`，其余 brpc API（`Channel`/`Server`/`Controller`/`baidu_std` 协议）零改动。
+
+### 2.2 核心类设计
+
+完全沿用 RDMA/UBShm 已验证的两层结构（Transport + Endpoint），保证代码风格与维护成本对齐：
+
+| 类 | 文件 | 职责 | 参考 |
+|----|------|------|------|
+| `brpc::UrmaTransport` | `src/brpc/urma_transport.{h,cpp}` | `Transport` 子类；持有 `UrmaEndpoint*` + fallback `TcpTransport`；三态 `URMA_ON/OFF/UNKNOWN`；`ContextInitOrDie` 校验协议/SSL | `rdma_transport.{h,cpp}` / `ubshm_transport.{h,cpp}` |
+| `urma::UrmaEndpoint` | `src/brpc/urma/urma_endpoint.{h,cpp}` | 每连接状态机；`SocketUser` 子类；`BAIDU_CACHELINE_ALIGNMENT`；Jetty/Segment 生命周期；CQ 轮询；收发数据路径 | `rdma/rdma_endpoint.{h,cpp}` |
+| `urma::UrmaConnect : public AppConnect` | 同上 | 客户端握手驱动；`StartConnect` 起后台 bthread 跑 `ProcessHandshakeAtClient` | `RdmaConnect` / `UBConnect` |
+| `urma::UrmaHandshake` | `src/brpc/urma/urma_handshake.{h,cpp}` | 握手策略基类 + v2/v3 子类；`ParsedHello` 中间结构；magic 分发 | `rdma/rdma_handshake.{h,cpp}` |
+| `urma::UrmaResource` | 同 endpoint | POD：`urma_jetty*`、`urma_cq*`、comp channel；预连接池 | `RdmaResource` |
+| `urma::BlockPool`（复用） | `src/brpc/rdma/block_pool.{h,cpp}` | 内存注册池；UrmaTransport 复用 RDMA 已有的 `block_pool`（URMA 底层同为 verbs 风格注册） | 现有 |
+| `urma::UrmaHelper` | `src/brpc/urma/urma_helper.{h,cpp}` | 全局初始化；`liburma` dlopen；设备/Jetty 管理 | `rdma/rdma_helper.{h,cpp}` |
+
+**关键设计决策**（与 RDMA 对齐，便于复用与评审）：
+
+1. **Compose TCP，不替换**：`UrmaTransport` 内嵌 `std::shared_ptr<TcpTransport>`，握手未完成/对端不支持/资源不可用时，所有数据路径方法回退到 TCP，保证现有 RPC 语义不破。
+2. **三态协商**：`URMA_UNKNOWN → URMA_ON / URMA_OFF`，数据路径统一判断 `_urma_state != URMA_OFF`，与 RDMA 的 `RDMA_UNKNOWN/ON/OFF` 完全对称。
+3. **Send/Recv + Immediate**：采用 `URMA_OP_SEND_WITH_IMM`（对应 `IBV_WR_SEND_WITH_IMM`），32-bit immediate 携带 recv-WR ack 数，实现 piggyback 流控，避免额外控制报文。不使用单边 RDMA Write/Read 作为主路径，降低收端预注册缓冲的复杂度。
+4. **双窗口 credit 流控**：`_remote_rq_window_size`（对端 recv 容量）+ `_sq_window_size`（本地 SQ 容量），均为 atomic；窗口耗尽返回 EAGAIN，`WaitEpollOut` 阻塞在 `_epollout_butex`。
+5. **复用 `block_pool` + IOBuf allocator 劫持**：URMA 同为 verbs 风格，需要注册内存。直接复用 `src/brpc/rdma/block_pool.{h,cpp}` 与 `rdma_helper.cpp` 中 `butil::iobuf::blockmem_allocate` 的替换逻辑，避免重复造轮子。若内存池后端需区分，通过 `RegisterCallback` 注入 Urma 版本的 `UrmaRegisterMemory`。
+6. **预连接 Jetty 池**：参考 `FLAGS_rdma_prepared_qp_cnt`（默认 1024），在 `GlobalUrmaInitializeOrDie` 时预分配 Jetty+CQ 集合，连接时从池中取，断开后 RESET 回收。
+7. **dlopen `liburma.so`**：参考 `rdma_helper.cpp::ReadRdmaDynamicLib`，运行时 `dlopen` + `dlsym` 解析 `urma_*` 符号，未启用时 `#else` 提供空 stub，保证非 URMA 构建干净。
+
+### 2.3 大小包协同：路线 C 的关键
+
+这是本提案相对于 #3226 OBMM 方案的**核心增量价值**。UBShmTransport（#3226）在 64 字节定长块上对小包极优，但对大包存在 `EMSGSIZE` 上限和 ~17k 块拷贝开销。UrmaTransport 通过 URMA 的 SGE 零拷贝对大包友好。两者协同设计：
+
+```mermaid
+flowchart LR
+    Sock["Socket<br/>(UrmaChannel)"]
+    Sock -->|"小包 &lt; FLAGS_urma_shm_split_threshold<br/>(默认 64KB)"| Small
+    Sock -->|"大包 &gt;= threshold"| Large
+    subgraph Small["小包路径"]
+        S1["走 UBSHMTransport / OBMM 共享内存<br/>Load/Store，~1μs"]
+        S2["适用：特征查询、CTR 分数、<br/>控制信令、ANN 倒排"]
+        S1 --- S2
+    end
+    subgraph Large["大包路径"]
+        L1["走 UrmaTransport<br/>URMA SGE 零拷贝，~2-5μs，无 EMSGSIZE"]
+        L2["适用：Embedding 大向量、<br/>模型参数拉取、特征序列化大包"]
+        L1 --- L2
+    end
+```
+
+**协同实现方式（两选一，倾向方案 A，留待社区讨论）**：
+
+**方案 A：应用层显式选择（推荐先行落地）**
+- 用户在 `ChannelOptions` 中显式为不同服务选择 `socket_mode`：小包服务用 `SOCKET_MODE_UBRING`，大包服务用 `SOCKET_MODE_URMA`。
+- 不引入跨 transport 的连接复用复杂度，符合 brpc「一个 Socket 一种 transport」的既有不变量（见 §3.3 of the RDMA 探索报告：A given Socket is bound to exactly one transport for its lifetime）。
+- 落地快、改动小、可测、可回退。
+
+**方案 B：单连接内按包分流（远期演进，本提案不立即实现）**
+- 新增 `SOCKET_MODE_HYBRID_UB_URMA`，`HybridTransport` 内部同时持有 `UBShmEndpoint` 与 `UrmaEndpoint`。
+- `CutFromIOBufList` 根据 `IOBuf` 总长度路由：小包走 SHM ring，大包走 URMA send。
+- 需要解决：双 Socket 生命周期、双握手、双 CQ 轮询、`_read_buf` 归并解析、`WaitEpollOut` 双路径唤醒。复杂度高，建议方案 A 稳定后再议。
+- 对应 #3217 路线 C「单后端自动切换」。
+
+**本提案先交付方案 A 的 UrmaTransport 主体**，并在文档中明确小包场景建议使用 `SOCKET_MODE_UBRING`（#3226），形成路线 C 的「双后端各司其职」格局。方案 B 作为后续演进方向记录。
+
+## 3. 与 brpc 架构的结合
+
+### 3.1 Transport 接口实现映射
+
+`Transport` 基类（`src/brpc/transport.h`）定义了 10 个纯虚方法。下表给出 `UrmaTransport` 每个方法的实现要点，及其与 `RdmaTransport` 的对应关系：
+
+| `Transport` 虚方法 | `UrmaTransport` 实现 | RDMA 对照 |
+|---|---|---|
+| `Init(socket, options)` | 构造 `UrmaEndpoint(socket)`；创建 fallback `TcpTransport`；若 `options.socket_mode == SOCKET_MODE_URMA` 则设 `_on_edge_trigger = urma::UrmaEndpoint::OnNewDataFromTcp` | `RdmaTransport::Init` |
+| `Release()` | `delete _urma_ep`；释放 Jetty/CQ 资源回预连接池 | `RdmaTransport::Release` |
+| `Reset(expected_nref)` | `UrmaEndpoint::Reset()`：Jetty 置 RESET，CQ drain，状态回 `UNINIT`，窗口计数器归零 | `RdmaEndpoint::Reset` |
+| `Connect()` | 返回 `std::make_shared<urma::UrmaConnect>()`（或用户 `_default_connect`） | `RdmaTransport::Connect` |
+| `CutFromIOBuf(buf)` | `_urma_ep && _urma_state != OFF` → `_urma_ep->CutFromIOBufList({buf},1)`；否则 `_tcp_transport->CutFromIOBuf(buf)` | `RdmaTransport::CutFromIOBuf` |
+| `CutFromIOBufList(bufs,n)` | URMA send 路径：构建 SGE → `urma_post_send` → 窗口扣减；EAGAIN 时返回 -1 | `RdmaEndpoint::CutFromIOBufList` |
+| `WaitEpollOut(butex,pollin,dt)` | `URMA_ON` 且 `!IsWritable()` → `butex_wait(_epollout_butex)`；否则委托 TCP。注意 URMA 同样无法靠 write 探测失败，wait 后需重检 `_socket->Failed()` | `RdmaTransport::WaitEpollOut` |
+| `ProcessEvent(attr)` | 与 TCP 版本一致：把 `OnEdge(socket)` 调度到 bthread | `RdmaTransport::ProcessEvent` |
+| `QueueMessage(msg,n,last)` | 与 TCP 版本一致；尊重 `FLAGS_urma_use_polling`/`FLAGS_urma_disable_bthread` | `RdmaTransport::QueueMessage` |
+| `Debug(os)` | 输出 `UrmaEndpoint::DebugInfo`（状态、Jetty、窗口大小、索引） | `RdmaTransport::Debug` |
+
+数据路径流向（与 RDMA 完全一致，便于评审对照）：
+
+```mermaid
+flowchart TD
+    subgraph Write["写路径"]
+        W1["Socket::DoWrite"] --> W2["UrmaTransport::CutFromIOBufList"]
+        W2 --> W3["UrmaEndpoint::CutFromIOBufList"]
+        W3 --> W4["构建 ibv_sge<br/>(从 IOBuf block refs + block_pool lkey)"]
+        W4 --> W5["urma_post_send(JETTY,<br/>wr=SEND_WITH_IMM, imm=ack_count)"]
+        W5 --> W6{"窗口扣减"}
+        W6 -->|窗口满| W7["EAGAIN -> WaitEpollOut 阻塞"]
+    end
+    subgraph Read["读路径"]
+        R1["URMA CQ comp-channel fd<br/>epoll 触发"] --> R2["Transport::ProcessEvent -><br/>OnEdge -> _on_edge_trigger"]
+        R2 --> R3["UrmaEndpoint::PollCq -> ibv_poll_cq"]
+        R3 --> R4["HandleCompletion"]
+        R4 -->|"SEND"| R5["回收 SQ 窗口<br/>WakeAsEpollOut"]
+        R4 -->|"RECV"| R6["cutn 进 _socket->_read_buf<br/>(zerocopy 阈值)"]
+        R6 --> R7["imm -> 补 _remote_rq_window_size<br/>PostRecv(1) + SendAck(1)"]
+        R7 --> R8["InputMessenger::ProcessNewMessage<br/>(协议解析与 TCP 完全一致)"]
+    end
+```
+
+### 3.2 注册机制（三处改动，完全沿用 RDMA 模板）
+
+参考探索结论：brpc 无动态注册，新 transport 需改三处：
+
+1. **`src/brpc/socket_mode.h`** — 新增枚举：
+```cpp
+enum SocketMode {
+    SOCKET_MODE_TCP   = 0,
+    SOCKET_MODE_RDMA  = 1,
+    SOCKET_MODE_UBRING = 2,
+    SOCKET_MODE_URMA  = 3   // 新增
+};
+```
+
+2. **`src/brpc/transport_factory.cpp`** — 两处 `if/else-if`，`#if BRPC_WITH_URMA` 守卫：
+```cpp
+int TransportFactory::ContextInitOrDie(SocketMode mode, bool serverOrNot, const void* _options) {
+    if (mode == SOCKET_MODE_TCP) { return 0; }
+#if BRPC_WITH_RDMA
+    else if (mode == SOCKET_MODE_RDMA) { return RdmaTransport::ContextInitOrDie(serverOrNot, _options); }
+#endif
+#if BRPC_WITH_UBRING
+    else if (mode == SOCKET_MODE_UBRING) { return UBShmTransport::ContextInitOrDie(serverOrNot, _options); }
+#endif
+#if BRPC_WITH_URMA
+    else if (mode == SOCKET_MODE_URMA) { return UrmaTransport::ContextInitOrDie(serverOrNot, _options); }
+#endif
+    ...
+}
+
+std::unique_ptr<Transport> TransportFactory::CreateTransport(SocketMode mode) {
+    ...
+#if BRPC_WITH_URMA
+    else if (mode == SOCKET_MODE_URMA) {
+        return std::unique_ptr<UrmaTransport>(new UrmaTransport());
+    }
+#endif
+}
+```
+
+3. **`CMakeLists.txt`** — 新增 option 与宏：
+```cmake
+option(WITH_URMA "With URMA (openEuler Unified Remote Memory Access)" OFF)
+if(WITH_URMA)
+    set(BRPC_WITH_URMA 1)
+    # liburma 由 dlopen 加载，无需 link；可选 link libumdk
+    list(APPEND BRPC_PUBLIC_LIBS ${URMA_LIB})
+endif()
+```
+
+所有 `urma*` 源文件统一 `#if BRPC_WITH_URMA ... #else <stub> #endif`，非启用构建零侵入（与 RDMA/UBRing 一致）。
+
+### 3.3 建链握手（双平面：TCP 控制 + URMA 数据）
+
+沿用 RDMA/UBShm 已验证的**「TCP 控制面 + 原生数据面」双平面**模式，避免重新发明轮子：
+
+- **控制面**：复用 brpc 现有的 TCP connect + `AppConnect` 钩子。TCP 连接建立后，`Socket::CheckConnectedAndKeepWrite` 调用 `_app_connect->StartConnect`，在后台 bthread 跑 URMA 握手。
+- **数据面**：握手成功后切换到 URMA Jetty 收发，TCP fd 仅保留用于 epoll 生命周期与 fallback。
+
+**客户端状态机**（`ProcessHandshakeAtClient`，参考 `RdmaEndpoint::ProcessHandshakeAtClient`）：
+
+```mermaid
+stateDiagram-v2
+    [*] --> C_ALLOC_JETTY
+    C_ALLOC_JETTY --> C_HELLO_SEND: AllocateResources()<br/>(从预连接池取 Jetty+CQ，或新建)
+    C_HELLO_SEND --> C_HELLO_WAIT: handshake->SendLocalHello()<br/>(发 "URMA"/"URM3" magic + 本地参数)
+    C_HELLO_WAIT --> C_ACK_SEND: negotiated=true<br/>ApplyRemoteHello + BringUpJetty
+    C_HELLO_WAIT --> C_ACK_SEND: negotiated=false → URMA_OFF
+    C_ACK_SEND --> ESTABLISHED: URMA_ON<br/>(WriteToFd flags_be bit0=URMA_OK)
+    C_ACK_SEND --> FALLBACK_TCP: URMA_OFF
+    ESTABLISHED --> [*]
+    FALLBACK_TCP --> [*]
+```
+
+**服务端状态机**（`ProcessHandshakeAtServer`，由 `_on_edge_trigger = OnNewDataFromTcp` 在首次可读时拉起）：
+
+```mermaid
+stateDiagram-v2
+    [*] --> S_HELLO_WAIT
+    S_HELLO_WAIT --> FALLBACK_TCP: 非 URMA magic<br/>(字节推回 _read_buf, TryReadOnTcp())
+    S_HELLO_WAIT --> S_ALLOC_JETTY: negotiated=true<br/>ApplyRemoteHello
+    S_HELLO_WAIT --> FALLBACK_TCP: negotiated=false -> URMA_OFF
+    S_ALLOC_JETTY --> S_BRINGUP_JETTY: AllocateResources()
+    S_BRINGUP_JETTY --> S_HELLO_SEND: BringUpJetty()
+    S_HELLO_SEND --> S_ACK_WAIT: SendLocalHello()
+    S_ACK_WAIT --> ESTABLISHED: client_ack_ok && !URMA_OFF<br/>(URMA_ON)
+    S_ACK_WAIT --> FAILED: client_ack_ok && URMA_OFF<br/>(SetFailed EPROTO)
+    S_ACK_WAIT --> FALLBACK_TCP: !client_ack_ok<br/>(URMA_OFF)
+    ESTABLISHED --> [*]: TryReadOnTcp()
+    FALLBACK_TCP --> [*]: TryReadOnTcp()
+    FAILED --> [*]
+```
+
+4 字节 ACK `URMA_OK=0x1` 为最终共识位，双端独立决策后确认，不一致即硬错误。与 RDMA 的 `HELLO_ACK_RDMA_OK` 完全对称。
+
+握手 IO 复用 `ReadFromFd`/`WriteToFd`（EAGAIN 感知循环，`_read_butex` 等待 + 50ms `WAIT_TIMEOUT_MS`），直接照搬 `rdma_endpoint.cpp:316-421`。
+
+### 3.4 CQ 作为第二个 Socket
+
+URMA 每连接需要一个额外可 poll 的 fd（CQ comp-channel，或 polling 模式下的 carrier）。参考 `RdmaEndpoint::AllocateResources`（`rdma_endpoint.cpp:1159-1178`）的成熟做法：
+
+- 创建第二个 brpc `Socket`，其 `fd` 为 CQ comp-channel fd，`options.user = this`（即 `UrmaEndpoint`），`options.on_edge_triggered_events = PollCq`。
+- 释放时 `SetFailed()` 该 CQ socket 并清 `_user`，避免 endpoint 被双重释放（参考 `rdma_endpoint.cpp:1370-1380`）。
+- Polling 模式下，参考 `PollerGroup`/`Poller`（每 bthread tag 一组），`FLAGS_urma_poller_num` 个轮询 bthread 循环遍历注册的 CQ socket id。
+
+### 3.5 内存管理
+
+URMA 底层为 verbs 风格，内存需注册。**直接复用 RDMA 的 `block_pool`**（`src/brpc/rdma/block_pool.{h,cpp}`），避免维护两套 slab 池：
+
+- `block_pool` 的 `RegisterCallback` 注入 `UrmaRegisterMemory`（使用 `IBV_ACCESS_LOCAL_WRITE | IBV_ACCESS_RELAXED_ORDERING`，失败回退 `LOCAL_WRITE`，与 `RdmaRegisterMemory` 一致）。
+- `UrmaHelper::GlobalUrmaInitializeOrDieImpl` 中同样劫持 `butil::iobuf::blockmem_allocate` → `BlockAllocate`，使所有 IOBuf block 天然 URMA 可用（参考 `rdma_helper.cpp:584-587`）。
+- 用户态注册内存：复用 `RegisterMemoryForRdma`/`DeregisterMemoryForRdma`/`GetLKey`（在 `block_pool` 的 `g_user_mrs` 表中），或新增 `urma::*` 别名包装以命名清晰。
+
+> **讨论点**：URMA 与 RDMA 是否共享同一个 `block_pool` 实例？若同进程内 RDMA 与 URMA 同时启用（一般不会），需评估设备间 lkey 命名空间。初步建议：单进程二选一，由 `ContextInitOrDie` 校验互斥。
+
+## 4. 关键接口与配置
+
+### 4.1 用户接口
+
+```cpp
+// 客户端
+brpc::ChannelOptions opt;
+opt.socket_mode = brpc::SOCKET_MODE_URMA;   // 选择 UrmaTransport
+opt.protocol = "baidu_std";                  // URMA 仅支持 baidu_std（同 RDMA）
+channel.Init("127.0.0.1:8000", &opt);
+
+// 服务端
+brpc::ServerOptions sopt;
+sopt.socket_mode = brpc::SOCKET_MODE_URMA;
+server.Start(port, &sopt);
+```
+
+`OptionsAvailableForUrma` / `OptionsAvailableOverUrma` 校验：拒绝 SSL、RTMP、NSHEAD、MONGO；仅允许 `baidu_std` 协议（与 `SupportedByRdma` 对齐）。
+
+### 4.2 gflags（对照 RDMA 命名，`urma_*` 前缀）
+
+| Flag | 默认 | 文件 | 用途 |
+|------|------|------|------|
+| `--urma_max_sge` | 0 | `urma_helper.cpp` | 每 WR SGE 上限；0=设备上限 |
+| `--urma_device` | "" | `urma_helper.cpp` | URMA 设备名；空=首个活跃 |
+| `--urma_sq_size` | 128 | `urma_endpoint.cpp` | 每连接 SQ 深度（[16,4096]） |
+| `--urma_rq_size` | 128 | `urma_endpoint.cpp` | 每连接 RQ 深度 |
+| `--urma_prepared_jetty_cnt` | 8 | `urma_endpoint.cpp` | 预连接 Jetty 池大小 |
+| `--urma_cqe_poll_once` | 32 | `urma_endpoint.cpp` | 每次 `ibv_poll_cq` 上限 |
+| `--urma_recv_zerocopy` | true | `urma_endpoint.cpp` | 接收零拷贝开关 |
+| `--urma_zerocopy_min_size` | 512 | `urma_endpoint.cpp` | 零拷贝阈值（小于则拷贝） |
+| `--urma_use_polling` | false | `urma_endpoint.cpp` | 轮询 vs 事件模式 |
+| `--urma_poller_num` | 1 | `urma_endpoint.cpp` | 每 bthread tag 轮询器数 |
+| `--urma_poller_yield` | false | `urma_endpoint.cpp` | 轮询循环 `bthread_yield` |
+| `--urma_disable_bthread` | false | `urma_endpoint.cpp` | 内联处理消息（不走 bthread） |
+| `--urma_trace_verbose` | false | `urma_endpoint.cpp` | 握手详细日志 |
+| `--urma_client_handshake_version` | 2 | `urma_handshake.cpp` | 握手版本（2=binary,3=protobuf） |
+| `--urma_memory_pool_initial_size_mb` | 1024 | `block_pool.cpp` | 内存池初始大小（复用） |
+| `--urma_memory_pool_max_regions` | 3 | `block_pool.cpp` | 内存池区域上限（硬上限16） |
+
+### 4.3 与 UBSHMTransport 的协同约定
+
+| 场景 | 建议 `socket_mode` | 理由 |
+|------|---------------------|------|
+| 同机 IPC（同主机进程间） | `SOCKET_MODE_UBRING` | Load/Store 亚微秒，零系统调用 |
+| 超节点跨机小包（<64KB，特征/分数/控制） | `SOCKET_MODE_UBRING`（`ub_shm_type=2` UBS-Mem）或 `SOCKET_MODE_URMA` | 两者均优；UBRing 更低延迟 |
+| 超节点跨机大包（>=64KB，Embedding/参数） | `SOCKET_MODE_URMA` | SGE 零拷贝，无 `EMSGSIZE` |
+| 传统 RoCE/IB 数据中心 | `SOCKET_MODE_URMA` 或 `SOCKET_MODE_RDMA` | URMA 统一语义，无 QP 爆炸 |
+
+`--urma_shm_split_threshold`（默认 64KB）为方案 B（hybrid）预留 flag，方案 A 阶段仅作文档阈值参考。
+
+## 5. 文件清单与改动范围
+
+### 5.1 新增文件
+
+```
+src/brpc/
+├── urma_transport.h          # UrmaTransport : public Transport
+├── urma_transport.cpp
+├── urma/
+│   ├── urma_endpoint.h       # UrmaEndpoint : public SocketUser, UrmaConnect, UrmaResource
+│   ├── urma_endpoint.cpp
+│   ├── urma_helper.h         # 全局初始化, liburma dlopen, 设备管理
+│   ├── urma_helper.cpp
+│   ├── urma_handshake.h      # 握手策略基类 + v2/v3 子类
+│   ├── urma_handshake.cpp
+│   ├── urma_handshake.proto  # v3 protobuf 握手（参考 rdma_handshake.proto）
+│   └── mock_urma.cpp          # URMA 链接时 mock（无 liburma 时编译，供 CI 测试）
+# URMA SDK 头文件（urma_api.h/urma_types.h/urma_opcode.h）通过系统安装提供，
+# CMake find_path(URMA_INCLUDE_PATH NAMES urma_api.h) 查找，不 vendored 到代码目录
+docs/
+├── cn/urma.md
+└── en/urma.md
+example/
+└── urma_performance/
+    ├── client.cpp
+    └── server.cpp
+test/
+└── brpc_urma_unittest.cpp
+```
+
+### 5.2 修改文件
+
+| 文件 | 改动 |
+|------|------|
+| `src/brpc/socket_mode.h` | 新增 `SOCKET_MODE_URMA = 3` |
+| `src/brpc/transport_factory.{h,cpp}` | 两个 `if/else-if` 分支，`#if BRPC_WITH_URMA` 守卫 |
+| `src/brpc/channel.h` | `ChannelOptions::socket_mode` 注释补充 URMA |
+| `src/brpc/server.h` | `ServerOptions::socket_mode` 注释补充 URMA |
+| `src/brpc/input_messenger.h` | `friend class urma::UrmaEndpoint;` |
+| `CMakeLists.txt` | `option(WITH_URMA ...)` + `BRPC_WITH_URMA` 宏 + 源文件列表 |
+
+### 5.3 复用文件（不改或最小改）
+
+- `src/brpc/rdma/block_pool.{h,cpp}` — 内存注册池（`RegisterCallback` 注入 Urma 版本）
+- `src/brpc/rdma/rdma_helper.cpp` — `blockmem_allocate` 劫持逻辑（提取为公共或 Urma 复制一份）
+- `src/brpc/tcp_transport.{h,cpp}` — fallback 依赖
+
+## 6. 落地计划
+
+### Phase 1：框架与最小可用（本提案目标）
+1. `SocketMode` + `TransportFactory` 注册通路。
+2. `UrmaTransport` + `UrmaEndpoint` 骨架：三态、TCP fallback、握手状态机（v2 binary）。
+3. 数据路径：`CutFromIOBufList` 走 `urma_post_send(SEND_WITH_IMM)`，`PollCq` + `HandleCompletion` 走 recv。
+4. 复用 `block_pool`。
+5. `example/urma_performance` 可跑通 `baidu_std` echo。
+6. 单测 `brpc_urma_unittest.cpp`（参考 `brpc_rdma_unittest.cpp` 与新写的 `brpc_ubring_unittest.cpp`）。
+
+### Phase 2：性能与协同
+1. 握手 v3（protobuf `UrmaHello`），前向兼容。
+2. Polling 模式 + `PollerGroup` per-tag。
+3. Unsignaled/solicited 完成抑制（降低 CPU）。
+4. 与 UBSHMTransport 的大小包协同文档与示例（方案 A）。
+
+### Phase 3：演进（留待社区讨论）
+1. 方案 B：`SOCKET_MODE_HYBRID_UB_URMA` 单连接按包分流。
+2. URMA-SHM 模式接入，与本机 UBRing 统一。
+3. GPU memory 直接注册（`urma_register_memory` over HBM），对接 GPUDirect 类语义。
+
+## 7. 风险与开放问题
+
+1. **硬件/驱动依赖**：URMA 需要 openEuler UB 驱动 + `liburma`。非 UB 平台只能 fallback TCP。是否接受 ko 依赖已在 #3217 征询，本提案沿用其结论。**CI 无 URMA 硬件时的可测试性由 §7.1 的 mock 保证**。
+2. **`block_pool` 复用边界**：URMA 与 RDMA 共享内存池的设备命名空间问题，倾向 `ContextInitOrDie` 互斥校验，需评审确认。
+3. **URMA API 成熟度**：`urma_post_send`/`urma_post_recv` 与 verbs 的差异需在 `UrmaEndpoint` 适配层抹平（如 `ibv_sge` 是否复用、imm_data 位宽）。Phase 1 需先对齐 SDK 头文件。
+4. **大小包协同方案选择**：方案 A（显式）vs 方案 B（自动分流）的取舍，请社区给出倾向。本提案默认先 A 后 B。
+5. **`baidu_std` 协议限制**：与 RDMA 一致，暂不支持其他协议。若社区有 URMA over HTTP 等需求，后续议。
+6. **跨平台**：URMA 当前为 Linux/openEuler 专有。macOS/Windows 提供 stub（同 RDMA/UBRing 的 `#else` 处理）。
+
+### 7.1 URMA Mock：无硬件环境下的 CI 可测试性
+
+**问题**：brpc 的 CI 运行在普通 Linux 容器中，没有 URMA 硬件/`liburma`。若 `WITH_URMA=ON` 时找不到 `liburma` 就 `FATAL_ERROR`，CI 无法构建和测试 UrmaTransport，回归风险高。
+
+**方案**：在 brpc 中内置一个 **链接时替换（link-time substitution）** 的 URMA mock。
+
+```mermaid
+flowchart TD
+    Build["cmake -DWITH_URMA=ON"]
+    Build --> Find{"find_library(URMA_LIB NAMES urma)"}
+    Find -->|"找到 liburma.so"| Real["编译 UrmaTransport<br/>链接 liburma<br/>URMA_USE_MOCK=0"]
+    Find -->|"未找到"| Mock["编译 UrmaTransport + mock_urma.cpp<br/>不链接 liburma<br/>URMA_USE_MOCK=1"]
+    Real --> Test1["硬件环境测试<br/>(真实 URMA)"]
+    Mock --> Test2["CI 无硬件环境测试<br/>(mock 完成路径)"]
+```
+
+**Mock 设计**（`src/brpc/urma/mock_urma.cpp`，Mooncake 同款模式）：
+
+| 设计点 | 实现 |
+|--------|------|
+| 替换方式 | **链接时**：mock 定义与 `liburma.so` 完全同名的 `urma_*` 自由函数符号，链接器按链接顺序选择 mock |
+| 对象存储 | 匿名命名空间内 `std::map<opaque_ptr*, int>` 注册表，按对象类型分表（`context_map`/`jfc_state_map`/`jfr_map`/`seg_map`/`jetty_map`/`target_jetty_map`） |
+| 成员校验 | 每个 `delete_*` 检查 map 成员资格，误用返回 `URMA_EINVAL` 而非崩溃 |
+| 完成路径 | 每个 posted send/recv WR 的 `user_ctx` 推入所属 JFC 的 FIFO，下次 `urma_poll_jfc` 返回 `URMA_CR_SUCCESS` |
+| 数据搬运 | **不搬运 payload 字节**--mock 是控制面替身，仅驱动握手/状态机；CI 数据路径测试不校验 payload 内容 |
+| 设备名契约 | `device->name == "mock_urma_device"`，测试用 `--urma_device=mock_urma_device` 匹配 |
+
+**Mock 覆盖的 `urma_*` 符号**（brpc transport 实际调用的全集）：
+
+```
+urma_init / urma_uninit
+urma_get_device_list / urma_free_device_list / urma_get_device_by_name
+urma_query_device / urma_get_eid_list / urma_free_eid_list
+urma_create_context / urma_delete_context
+urma_create_jfce / urma_delete_jfce
+urma_create_jfc / urma_delete_jfc
+urma_create_jfr / urma_delete_jfr
+urma_register_seg / urma_unregister_seg
+urma_import_seg / urma_unimport_seg
+urma_create_jetty / urma_delete_jetty
+urma_import_jetty / urma_unimport_jetty
+urma_bind_jetty / urma_unbind_jetty / urma_modify_jetty
+urma_post_jetty_send_wr       (send 路径)
+urma_post_jfr_wr              (recv 路径，Mooncake mock 未含，brpc 新增)
+urma_poll_jfc                  (完成轮询)
+urma_get_async_event / urma_ack_async_event
+```
+
+> **与 Mooncake mock 的差异**：Mooncake 的 transport 是单边 write/read（仅 JFS），mock 不含 `urma_post_jfr_wr`。brpc 的 `UrmaEndpoint` 是双边 send/recv，recv 路径走 `urma_post_jfr_wr`，故 brpc mock 新增该函数--将 recv WR 的 `user_ctx` 推入 JFC 的 `pending_recv` 队列，`urma_poll_jfc` 先排空 send 完成再排空 recv 完成（`cr.flag.bs.s_r` 区分）。
+
+**CMake 集成**（`CMakeLists.txt`）：
+
+```cmake
+if(WITH_URMA)
+    find_library(URMA_LIB NAMES urma)
+    if(URMA_LIB)
+        message(STATUS "Found liburma: ${URMA_LIB}")
+        set(URMA_USE_MOCK 0)
+    else()
+        message(WARNING "liburma not found; building UrmaTransport with the bundled mock.")
+        set(URMA_USE_MOCK 1)
+    endif()
+endif()
+# ... 源文件收集 ...
+if(WITH_URMA AND NOT URMA_USE_MOCK)
+    list(REMOVE_ITEM BRPC_SOURCES
+         "${PROJECT_SOURCE_DIR}/src/brpc/urma/mock_urma.cpp")
+endif()
+# ... 链接 ...
+if(WITH_URMA)
+    if(NOT URMA_USE_MOCK)
+        list(APPEND DYNAMIC_LIB ${URMA_LIB})
+    endif()
+endif()
+```
+
+**Mock 自身守卫**：`mock_urma.cpp` 包裹在 `#if BRPC_WITH_URMA ... #endif` 中，`WITH_URMA=OFF` 时不编译（与其它 URMA 源一致）。
+
+**CI 保证**：
+
+- `WITH_URMA=OFF`：所有 URMA 源编译为空 stub，mock 不参与编译，brpc 主库与现有行为一致。
+- `WITH_URMA=ON` + 无 `liburma`（CI 默认）：mock 编译进 brpc，`brpc_urma_unittest` 链接 mock，跑通握手序列化/状态机/fallback 等纯逻辑测试。
+- `WITH_URMA=ON` + 有 `liburma`（硬件环境）：mock 从源列表移除，链接真实 `liburma`，跑通真实 URMA 数据路径。
+
+## 8. 与既有提案的关系
+
+| 提案 | 关系 |
+|------|------|
+| #3167 | 本提案完全基于其落地的 `Transport` 抽象，不再讨论架构改造 |
+| #3217 路线 B | 本提案即路线 B 的具体设计 |
+| #3217 路线 C | 本提案 §2.3 给出方案 A（先行）+ 方案 B（演进），与 #3226 OBMM 形成 C |
+| #3226 | OBMM-ShmTransport 为小包路径，本提案 UrmaTransport 为大包/跨节点路径，互补 |
+
+## 9. 致谢
+
+感谢 @chenBright @wwbmmm @yanglimingcn @ivanallen @dwh110 在 #3167 / #3217 / #3226 中的深入讨论，本提案在架构取舍上大量吸纳了这些讨论结论（尤其是 wwbmmm 关于「Transport 持有协议私有成员、Socket 只持 `_transport` 指针」的解耦思路，已成为现有 `Transport` 接口的设计基线）。
+
+欢迎各位继续评审，特别是：
+- 方案 A vs 方案 B 的倾向
+- `block_pool` 复用 vs 独立
+- URMA SDK API 与 verbs 的差异适配
+- Phase 划分与落地节奏
diff --git a/src/brpc/adapter_transport.cpp b/src/brpc/adapter_transport.cpp
index bc06df70e4..f7db329f26 100644
--- a/src/brpc/adapter_transport.cpp
+++ b/src/brpc/adapter_transport.cpp
@@ -22,12 +22,82 @@
 #include <unistd.h>
 
 #include "brpc/input_messenger.h"
+#include "brpc/destroyable.h"
+#include "brpc/handshake/rdma_handshake.h"
+#include "brpc/handshake/ubshm_handshake.h"
+#if BRPC_WITH_RDMA
+#include "brpc/rdma/rdma_helper.h"
+#endif
+#if BRPC_WITH_UBRING
+#include "brpc/ubshm/ub_helper.h"
+#include "brpc/ubshm/ubr_trx.h"
+#endif
 #include "brpc/rdma_transport.h"
 #include "brpc/tcp_transport.h"
 #include "brpc/ubshm_transport.h"
 
 namespace brpc {
 
+namespace {
+
+class AdapterConnect : public AppConnect {
+public:
+    explicit AdapterConnect(const std::shared_ptr<AppConnect>& app_connect)
+        : _app_connect(app_connect) {}
+
+    void StartConnect(const Socket* socket,
+                      void (*done)(int, void*), void* data) override {
+        ApplicationConnectTask* task = new ApplicationConnectTask{
+            socket, _app_connect, done, data};
+        if (AdapterTransport::StartClientUpgrade(
+                socket, OnUpgradeComplete, task) != 0) {
+            AdapterTransport::Get(socket)->CompleteConnection(
+                handshake::FAILED);
+            const int error = errno != 0 ? errno : EAGAIN;
+            delete task;
+            done(error, data);
+        }
+    }
+
+    void StopConnect(Socket*) override {}
+
+private:
+    struct ApplicationConnectTask {
+        const Socket* socket;
+        std::shared_ptr<AppConnect> app_connect;
+        void (*done)(int, void*);
+        void* data;
+    };
+
+    static void OnApplicationComplete(int error, void* arg) {
+        std::unique_ptr<ApplicationConnectTask> task(
+            static_cast<ApplicationConnectTask*>(arg));
+        task->done(error, task->data);
+    }
+
+    static void OnUpgradeComplete(int error, void* arg) {
+        ApplicationConnectTask* task =
+            static_cast<ApplicationConnectTask*>(arg);
+        if (error != 0 || !task->app_connect) {
+            std::unique_ptr<ApplicationConnectTask> owned(task);
+            task->done(error, task->data);
+            return;
+        }
+        task->app_connect->StartConnect(
+            task->socket, OnApplicationComplete, task);
+    }
+
+    std::shared_ptr<AppConnect> _app_connect;
+};
+
+struct ClientHandshakeTask {
+    AdapterTransport* adapter;
+    void (*done)(int, void*);
+    void* data;
+};
+
+}  // namespace
+
 AdapterTransport::~AdapterTransport() = default;
 
 AdapterTransport* AdapterTransport::Get(Socket* socket) {
@@ -40,6 +110,192 @@ const AdapterTransport* AdapterTransport::Get(const Socket* socket) {
     return static_cast<const AdapterTransport*>(socket->_transport.get());
 }
 
+int AdapterTransport::StartClientUpgrade(const Socket* socket,
+                                         void (*done)(int, void*),
+                                         void* data) {
+    AdapterTransport* adapter = Get(const_cast<Socket*>(socket));
+    ClientHandshakeTask* task = new ClientHandshakeTask{adapter, done, data};
+    bthread_t tid;
+    bthread_attr_t attr = BTHREAD_ATTR_NORMAL;
+    bthread_attr_set_name(&attr, "StartClientUpgrade");
+    if (bthread_start_background(&tid, &attr,
+                                 ProcessClientHandshake, task) < 0) {
+        delete task;
+        return -1;
+    }
+    return 0;
+}
+
+ParseResult AdapterTransport::ProcessUpgradeReadable(butil::IOBuf* source) {
+    ParseResult result;
+    if (_socket->parsing_context() != NULL) {
+        handshake::ServerHandshakeContext* context =
+            static_cast<handshake::ServerHandshakeContext*>(
+                _socket->parsing_context());
+        CHECK(context->adapter() != NULL);
+        result = context->adapter()->ExecuteServerHandshake(source, _socket);
+    } else {
+        const char* first = static_cast<const char*>(source->fetch1());
+        handshake::HandshakeAdapter* adapter =
+            first != NULL && *first == 'U'
+            ? handshake::GetUBShmServerHandshakeAdapter()
+            : handshake::GetRdmaServerHandshakeAdapter();
+        result = adapter->ExecuteServerHandshake(source, _socket);
+    }
+    const int phase = _handshake.phase();
+    if (!connection_completed() &&
+        (phase == handshake::ESTABLISHED ||
+         phase == handshake::FALLBACK_TCP || phase == handshake::FAILED)) {
+        CompleteConnection(static_cast<handshake::Phase>(phase));
+    }
+    return result;
+}
+
+void AdapterTransport::CompleteConnection(handshake::Phase terminal_phase) {
+    CHECK(terminal_phase == handshake::ESTABLISHED ||
+          terminal_phase == handshake::FALLBACK_TCP ||
+          terminal_phase == handshake::FAILED);
+    if (terminal_phase == handshake::FAILED &&
+        _handshake.phase() != handshake::FAILED) {
+        _handshake.MarkFailed();
+    }
+    int expected = 0;
+    _connection_completed.compare_exchange_strong(
+        expected, 1, butil::memory_order_release,
+        butil::memory_order_relaxed);
+}
+
+void* AdapterTransport::ProcessClientHandshake(void* arg) {
+    std::unique_ptr<ClientHandshakeTask> task(
+        static_cast<ClientHandshakeTask*>(arg));
+    AdapterTransport* adapter = task->adapter;
+    SocketUniquePtr socket(adapter->_socket);
+    int connect_error = 0;
+
+#if BRPC_WITH_RDMA
+    if (adapter->_mode == SOCKET_MODE_RDMA) {
+        RdmaTransport* transport = static_cast<RdmaTransport*>(
+            adapter->_high_speed_transport.get());
+        if (!rdma::IsRdmaAvailable()) {
+            adapter->FallbackToTcp();
+            adapter->CompleteConnection(handshake::FALLBACK_TCP);
+            task->done(0, task->data);
+            return NULL;
+        }
+
+        std::unique_ptr<rdma::RdmaHandshakeAdapter> protocol =
+            transport->CreateClientHandshakeAdapter();
+        CHECK(protocol != NULL);
+        rdma::ParsedHello remote{};
+        handshake::ClientHandshakeCallbacks callbacks{};
+        callbacks.codec = protocol->MakeCodec(&remote);
+        callbacks.transport.prepare_resources = [&]() {
+            if (transport->PrepareUpgradeResources() == 0) {
+                return handshake::STEP_OK;
+            }
+            errno = 0;
+            return handshake::STEP_FALLBACK;
+        };
+        callbacks.transport.negotiate_resources = [&]() {
+            return transport->NegotiateUpgradeResources(remote, false) == 0
+                ? handshake::STEP_OK : handshake::STEP_FALLBACK;
+        };
+        callbacks.transport.set_high_speed_active = [transport]() {
+            transport->ActivateUpgrade();
+        };
+        callbacks.transport.set_tcp_active = [transport]() {
+            transport->DeactivateUpgrade();
+        };
+        callbacks.transport.on_failed = [&]() {
+            const int saved_errno = errno != 0 ? errno : EPROTO;
+            socket->SetFailed(saved_errno,
+                              "Fail to complete rdma handshake from %s: %s",
+                              socket->description().c_str(),
+                              berror(saved_errno));
+        };
+        const handshake::StepResult result = adapter->_handshake.RunClient(callbacks);
+        if (result == handshake::STEP_ERROR) {
+            connect_error = errno != 0 ? errno : EPROTO;
+        }
+        adapter->CompleteConnection(static_cast<handshake::Phase>(
+            adapter->_handshake.phase()));
+        task->done(connect_error, task->data);
+        return NULL;
+    }
+#endif
+
+#if BRPC_WITH_UBRING
+    if (adapter->_mode == SOCKET_MODE_UBRING) {
+        UBShmTransport* transport = static_cast<UBShmTransport*>(
+            adapter->_high_speed_transport.get());
+        if (!ubring::IsUBAvailable()) {
+            adapter->FallbackToTcp();
+            adapter->CompleteConnection(handshake::FALLBACK_TCP);
+            task->done(0, task->data);
+            return NULL;
+        }
+
+        const size_t local_shm_len =
+            static_cast<size_t>(ubring::FLAGS_data_queue_size) * MB_TO_BYTE;
+        ubring::SHM local_trx_shm = {
+            NULL, local_shm_len, 0, {0}, static_cast<uint32_t>(socket->fd())};
+        const std::string shm_name_str =
+            butil::endpoint2str(socket->local_side());
+        ubring::HelloMessage remote{};
+        ubring::UBShmHandshakeAdapter wire;
+        handshake::ClientHandshakeCallbacks callbacks{};
+        callbacks.codec = wire.MakeCodec();
+        callbacks.codec.build_hello = [&](bool enabled, std::string* payload) {
+            CHECK(enabled);
+            return wire.BuildHello(true, local_shm_len, shm_name_str.c_str(),
+                                   payload);
+        };
+        callbacks.codec.parse_hello = [&](const std::string& payload) {
+            return wire.ParseHello(payload, &remote);
+        };
+        callbacks.transport.prepare_resources = [&]() {
+            return transport->PrepareUpgradeResources(
+                       &local_trx_shm, shm_name_str.c_str()) == 0
+                ? handshake::STEP_OK : handshake::STEP_FALLBACK;
+        };
+        callbacks.transport.negotiate_resources = [&]() {
+            return transport->NegotiateUpgradeResources(
+                       &local_trx_shm, shm_name_str.c_str()) == 0
+                ? handshake::STEP_OK : handshake::STEP_FALLBACK;
+        };
+        callbacks.transport.set_high_speed_active = [transport]() {
+            transport->ActivateUpgrade();
+        };
+        callbacks.transport.set_tcp_active = [transport]() {
+            transport->DeactivateUpgrade();
+        };
+        callbacks.transport.on_failed = [&]() {
+            const int saved_errno = errno != 0 ? errno : EPROTO;
+            socket->SetFailed(saved_errno,
+                              "Fail to complete ubring handshake from %s: %s",
+                              socket->description().c_str(),
+                              berror(saved_errno));
+        };
+        const handshake::StepResult result = adapter->_handshake.RunClient(callbacks);
+        if (result == handshake::STEP_OK) {
+            transport->FinishUpgrade();
+        }
+        if (result == handshake::STEP_ERROR) {
+            connect_error = errno != 0 ? errno : EPROTO;
+        }
+        adapter->CompleteConnection(static_cast<handshake::Phase>(
+            adapter->_handshake.phase()));
+        task->done(connect_error, task->data);
+        return NULL;
+    }
+#endif
+
+    socket->SetFailed(EPROTO, "Unsupported client transport handshake");
+    adapter->CompleteConnection(handshake::FAILED);
+    task->done(EPROTO, task->data);
+    return NULL;
+}
+
 void AdapterTransport::Init(Socket* socket, const SocketOptions& options) {
     CHECK_EQ(_mode, options.socket_mode);
     _socket = socket;
@@ -67,6 +323,7 @@ void AdapterTransport::Init(Socket* socket, const SocketOptions& options) {
         }
     }
     _handshake.Reset(socket);
+    _connection_completed.store(0, butil::memory_order_relaxed);
     _tcp_transport.reset(new TcpTransport);
     _tcp_transport->Init(socket, options);
 
@@ -102,12 +359,13 @@ int AdapterTransport::Reset(int32_t expected_nref) {
     }
     _tcp_transport->Reset(expected_nref);
     _handshake.Reset(_socket);
+    _connection_completed.store(0, butil::memory_order_relaxed);
     return 0;
 }
 
 std::shared_ptr<AppConnect> AdapterTransport::Connect() {
     if (_high_speed_transport) {
-        return _high_speed_transport->Connect();
+        return std::make_shared<AdapterConnect>(_default_connect);
     }
     return _tcp_transport->Connect();
 }
@@ -150,6 +408,21 @@ void AdapterTransport::Debug(std::ostream& os) {
     if (_high_speed_transport) {
         _high_speed_transport->Debug(os);
     }
+    const char* state = "UNKNOWN";
+    switch (_handshake.phase()) {
+    case handshake::UNINITIALIZED: state = "UNINITIALIZED"; break;
+    case handshake::PREPARING: state = "PREPARING"; break;
+    case handshake::HELLO_SEND: state = "HELLO_SEND"; break;
+    case handshake::HELLO_WAIT: state = "HELLO_WAIT"; break;
+    case handshake::NEGOTIATING: state = "NEGOTIATING"; break;
+    case handshake::ACK_SEND: state = "ACK_SEND"; break;
+    case handshake::ACK_WAIT: state = "ACK_WAIT"; break;
+    case handshake::ESTABLISHED: state = "ESTABLISHED"; break;
+    case handshake::FALLBACK_TCP: state = "FALLBACK_TCP"; break;
+    case handshake::FAILED: state = "FAILED"; break;
+    }
+    os << "\nhandshake_state=" << state
+       << "\nhandshake_version=" << _handshake.protocol_version();
 }
 
 void AdapterTransport::FallbackToTcp() {
diff --git a/src/brpc/adapter_transport.h b/src/brpc/adapter_transport.h
index a56c8e96e9..637a508435 100644
--- a/src/brpc/adapter_transport.h
+++ b/src/brpc/adapter_transport.h
@@ -23,6 +23,7 @@
 #include "brpc/socket_mode.h"
 #include "brpc/transport.h"
 #include "brpc/transport_handshake.h"
+#include "brpc/parse_result.h"
 
 namespace brpc {
 
@@ -57,14 +58,27 @@ class AdapterTransport : public Transport {
     Transport* high_speed_transport() const {
         return _high_speed_transport.get();
     }
+    bool upgrade_capable() const { return _high_speed_transport != NULL; }
 
     static AdapterTransport* Get(Socket* socket);
     static const AdapterTransport* Get(const Socket* socket);
 
+    // The only client-side upgrade entry point. Concrete transports provide
+    // resources; AdapterTransport owns the handshake orchestration.
+    static int StartClientUpgrade(const Socket* socket,
+                                  void (*done)(int, void*), void* data);
+
+    ParseResult ProcessUpgradeReadable(butil::IOBuf* source);
+    void CompleteConnection(handshake::Phase terminal_phase);
+    bool connection_completed() const {
+        return _connection_completed.load(butil::memory_order_acquire) != 0;
+    }
+
     static void OnNewDataFromTcp(Socket* socket);
 
 private:
-    explicit AdapterTransport(SocketMode mode) : _mode(mode) {}
+    explicit AdapterTransport(SocketMode mode)
+        : _mode(mode), _connection_completed(0) {}
     ~AdapterTransport() override;
 
     Transport* ActiveTransport() const;
@@ -73,11 +87,13 @@ class AdapterTransport : public Transport {
     void TryReadOnTcp();
     void ProcessTcpEvent();
     void CheckUnexpectedTcpData();
+    static void* ProcessClientHandshake(void* arg);
 
     SocketMode _mode;
     handshake::HandshakeSession _handshake;
     std::unique_ptr<TcpTransport> _tcp_transport;
     std::unique_ptr<Transport> _high_speed_transport;
+    butil::atomic<int> _connection_completed;
 };
 
 }  // namespace brpc
diff --git a/src/brpc/handshake/handshake_adapter.cpp b/src/brpc/handshake/handshake_adapter.cpp
index 8c0f1153c4..0c9c72765a 100644
--- a/src/brpc/handshake/handshake_adapter.cpp
+++ b/src/brpc/handshake/handshake_adapter.cpp
@@ -29,9 +29,9 @@ namespace handshake {
 // ACK, whose frame has no protocol magic of its own.
 ParseResult StandardHandshakeAdapter::ExecuteServerHandshake(
     butil::IOBuf* source, Socket* socket) {
-    const StepResult result = RunServerHandshake(source, socket);
+    const StepResult result = RunServerStep(source, socket);
     if (result == STEP_NEED_MORE) {
-        if (GetSession(socket)->phase() == AckWaitPhase(socket) &&
+        if (GetSession(socket)->phase() == ACK_WAIT &&
             socket->parsing_context() == NULL) {
             ServerHandshakeContext* context =
                 ServerHandshakeContext::Create(this);
diff --git a/src/brpc/handshake/handshake_adapter.h b/src/brpc/handshake/handshake_adapter.h
index b85d883602..2a344c9ed3 100644
--- a/src/brpc/handshake/handshake_adapter.h
+++ b/src/brpc/handshake/handshake_adapter.h
@@ -49,8 +49,8 @@ class HandshakeAdapter {
     DISALLOW_COPY_AND_ASSIGN(HandshakeAdapter);
 };
 
-// Reusable InputMessenger implementation. Protocols normally derive from this
-// class and provide only the Session driver and phase hooks.
+// Reusable InputMessenger implementation. Protocol adapters provide only the
+// protocol-specific server step; the common session owns all phases.
 class StandardHandshakeAdapter : public HandshakeAdapter {
 public:
     ParseResult ExecuteServerHandshake(
@@ -59,10 +59,9 @@ class StandardHandshakeAdapter : public HandshakeAdapter {
 protected:
     StandardHandshakeAdapter() = default;
 
-    virtual StepResult RunServerHandshake(
+    virtual StepResult RunServerStep(
         butil::IOBuf* source, Socket* socket) = 0;
     virtual HandshakeSession* GetSession(Socket* socket) const = 0;
-    virtual int AckWaitPhase(const Socket* socket) const = 0;
 
 private:
     DISALLOW_COPY_AND_ASSIGN(StandardHandshakeAdapter);
diff --git a/src/brpc/handshake/rdma_handshake.cpp b/src/brpc/handshake/rdma_handshake.cpp
index ccf8833f6b..292bfde55d 100644
--- a/src/brpc/handshake/rdma_handshake.cpp
+++ b/src/brpc/handshake/rdma_handshake.cpp
@@ -399,10 +399,9 @@ class RdmaServerHandshakeAdapter : public StandardHandshakeAdapter {
     RdmaServerHandshakeAdapter() = default;
 
 protected:
-    StepResult RunServerHandshake(
+    StepResult RunServerStep(
         butil::IOBuf* source, Socket* socket) override;
     HandshakeSession* GetSession(Socket* socket) const override;
-    int AckWaitPhase(const Socket* socket) const override;
 
 private:
     StepResult RunFallbackServerHandshake(
@@ -489,31 +488,19 @@ HandshakeSession* RdmaServerHandshakeAdapter::GetSession(
     return AdapterTransport::Get(socket)->handshake_session();
 }
 
-int RdmaServerHandshakeAdapter::AckWaitPhase(const Socket* socket) const {
-#if BRPC_WITH_RDMA
-    if (socket->socket_mode() == SOCKET_MODE_RDMA) {
-        return RdmaTransport::S_ACK_WAIT;
-    }
-#endif
-    return FALLBACK_ACK_WAIT;
-}
-
 StepResult RdmaServerHandshakeAdapter::RunFallbackServerHandshake(
     butil::IOBuf* source, Socket* socket) {
     IOBufHandshakeInput input(source);
     ServerHandshakeCallbacks callbacks{};
-    callbacks.phases = HandshakePhases{
-        FALLBACK_PREPARE, FALLBACK_HELLO_SEND, FALLBACK_HELLO_WAIT,
-        FALLBACK_NEGOTIATE, FALLBACK_ACK_SEND, FALLBACK_ACK_WAIT};
     callbacks.fallback_on_not_mine = false;
     callbacks.codecs.push_back(MakeRdmaFallbackCodec(2));
     callbacks.codecs.push_back(MakeRdmaFallbackCodec(3));
     callbacks.input = &input;
-    callbacks.prepare_resources = []() { return STEP_OK; };
-    callbacks.negotiate_resources = []() { return STEP_OK; };
-    callbacks.set_high_speed_active = []() {};
-    callbacks.set_tcp_active = []() {};
-    callbacks.on_failed = []() {};
+    callbacks.transport.prepare_resources = []() { return STEP_OK; };
+    callbacks.transport.negotiate_resources = []() { return STEP_OK; };
+    callbacks.transport.set_high_speed_active = []() {};
+    callbacks.transport.set_tcp_active = []() {};
+    callbacks.transport.on_failed = []() {};
     return GetSession(socket)->RunServer(callbacks);
 }
 
@@ -521,18 +508,13 @@ StepResult RdmaServerHandshakeAdapter::RunFallbackServerHandshake(
 StepResult RdmaServerHandshakeAdapter::RunRdmaServerHandshake(
     butil::IOBuf* source, Socket* socket) {
     RdmaTransport* transport = RdmaTransport::Get(socket);
-    rdma::RdmaEndpoint* ep = transport->_rdma_ep;
-    CHECK(ep != NULL);
+    CHECK(transport->GetRdmaEp() != NULL);
 
     rdma::ParsedHello remote{};
     std::vector<std::unique_ptr<rdma::RdmaHandshakeAdapter> > protocols =
-        rdma::CreateServerHandshakeAdapters(ep);
+        transport->CreateServerHandshakeAdapters();
     IOBufHandshakeInput input(source);
     ServerHandshakeCallbacks callbacks{};
-    callbacks.phases = HandshakePhases{
-        RdmaTransport::S_ALLOC_QPCQ, RdmaTransport::S_HELLO_SEND,
-        RdmaTransport::S_HELLO_WAIT, RdmaTransport::S_BRINGUP_QP,
-        0, RdmaTransport::S_ACK_WAIT};
     callbacks.fallback_on_not_mine = false;
     callbacks.input = &input;
     for (size_t i = 0; i < protocols.size(); ++i) {
@@ -543,52 +525,47 @@ StepResult RdmaServerHandshakeAdapter::RunRdmaServerHandshake(
             const std::string& payload) {
             const StepResult result = parse_hello(payload);
             if (result == STEP_FALLBACK) {
-                transport->_rdma_state = RdmaTransport::RDMA_OFF;
+                transport->DeactivateUpgrade();
             }
             return result;
         };
         callbacks.codecs.push_back(codec);
     }
-    callbacks.prepare_resources = [&]() {
-        ep->ApplyRemoteInfo(remote);
-        if (ep->AllocateResources() < 0) {
+    callbacks.transport.prepare_resources = [&]() {
+        if (transport->NegotiateUpgradeResources(remote, true) < 0) {
             PLOG(WARNING)
                 << "Fail to allocate rdma resources, fallback to tcp:"
                 << socket->description();
-            transport->_rdma_state = RdmaTransport::RDMA_OFF;
+            transport->DeactivateUpgrade();
             return STEP_FALLBACK;
         }
         return STEP_OK;
     };
-    callbacks.negotiate_resources = [&]() {
-        if (ep->BringUpQp(remote, true) < 0) {
-            transport->_rdma_state = RdmaTransport::RDMA_OFF;
-            return STEP_FALLBACK;
-        }
+    callbacks.transport.negotiate_resources = [&]() {
         return STEP_OK;
     };
     callbacks.validate_established = [&]() {
         if (!source->empty() ||
-            transport->_rdma_state == RdmaTransport::RDMA_OFF) {
+            !transport->UpgradeActive()) {
             return STEP_ERROR;
         }
         return STEP_OK;
     };
-    callbacks.set_high_speed_active = [transport]() {
-        transport->SetHighSpeedAvailable(true);
+    callbacks.transport.set_high_speed_active = [transport]() {
+        transport->ActivateUpgrade();
     };
-    callbacks.set_tcp_active = [transport]() {
-        transport->SetHighSpeedAvailable(false);
+    callbacks.transport.set_tcp_active = [transport]() {
+        transport->DeactivateUpgrade();
     };
-    callbacks.on_failed = []() {};
+    callbacks.transport.on_failed = []() {};
     return GetSession(socket)->RunServer(callbacks);
 }
 #endif
 
-StepResult RdmaServerHandshakeAdapter::RunServerHandshake(
+StepResult RdmaServerHandshakeAdapter::RunServerStep(
     butil::IOBuf* source, Socket* socket) {
 #if BRPC_WITH_RDMA
-    if (socket->socket_mode() == SOCKET_MODE_RDMA) {
+    if (AdapterTransport::Get(socket)->upgrade_capable()) {
         return RunRdmaServerHandshake(source, socket);
     }
 #endif
diff --git a/src/brpc/handshake/ubshm_handshake.cpp b/src/brpc/handshake/ubshm_handshake.cpp
index 328a7b5ccb..6e514edd8d 100644
--- a/src/brpc/handshake/ubshm_handshake.cpp
+++ b/src/brpc/handshake/ubshm_handshake.cpp
@@ -209,10 +209,9 @@ class UBShmServerHandshakeAdapter : public StandardHandshakeAdapter {
     UBShmServerHandshakeAdapter() = default;
 
 protected:
-    StepResult RunServerHandshake(
+    StepResult RunServerStep(
         butil::IOBuf* source, Socket* socket) override;
     HandshakeSession* GetSession(Socket* socket) const override;
-    int AckWaitPhase(const Socket* socket) const override;
 
 private:
     StepResult RunFallbackServerHandshake(
@@ -279,31 +278,18 @@ HandshakeSession* UBShmServerHandshakeAdapter::GetSession(
     return AdapterTransport::Get(socket)->handshake_session();
 }
 
-int UBShmServerHandshakeAdapter::AckWaitPhase(
-    const Socket* socket) const {
-#if BRPC_WITH_UBRING
-    if (socket->socket_mode() == SOCKET_MODE_UBRING) {
-        return UBShmTransport::S_ACK_WAIT;
-    }
-#endif
-    return FALLBACK_ACK_WAIT;
-}
-
 StepResult UBShmServerHandshakeAdapter::RunFallbackServerHandshake(
     butil::IOBuf* source, Socket* socket) {
     IOBufHandshakeInput input(source);
     ServerHandshakeCallbacks callbacks{};
-    callbacks.phases = HandshakePhases{
-        FALLBACK_PREPARE, FALLBACK_HELLO_SEND, FALLBACK_HELLO_WAIT,
-        FALLBACK_NEGOTIATE, FALLBACK_ACK_SEND, FALLBACK_ACK_WAIT};
     callbacks.fallback_on_not_mine = false;
     callbacks.codecs.push_back(MakeUBShmFallbackCodec());
     callbacks.input = &input;
-    callbacks.prepare_resources = []() { return STEP_OK; };
-    callbacks.negotiate_resources = []() { return STEP_OK; };
-    callbacks.set_high_speed_active = []() {};
-    callbacks.set_tcp_active = []() {};
-    callbacks.on_failed = []() {};
+    callbacks.transport.prepare_resources = []() { return STEP_OK; };
+    callbacks.transport.negotiate_resources = []() { return STEP_OK; };
+    callbacks.transport.set_high_speed_active = []() {};
+    callbacks.transport.set_tcp_active = []() {};
+    callbacks.transport.on_failed = []() {};
     return GetSession(socket)->RunServer(callbacks);
 }
 
@@ -311,17 +297,12 @@ StepResult UBShmServerHandshakeAdapter::RunFallbackServerHandshake(
 StepResult UBShmServerHandshakeAdapter::RunUBShmServerHandshake(
     butil::IOBuf* source, Socket* socket) {
     UBShmTransport* transport = UBShmTransport::Get(socket);
-    ubring::UBShmEndpoint* ep = transport->_ub_ep;
-    CHECK(ep != NULL);
+    CHECK(transport->GetUBShmEp() != NULL);
 
     ubring::HelloMessage remote{};
     ubring::UBShmHandshakeAdapter wire;
     IOBufHandshakeInput input(source);
     ServerHandshakeCallbacks callbacks{};
-    callbacks.phases = HandshakePhases{
-        UBShmTransport::S_ALLOC_SHM, UBShmTransport::S_HELLO_SEND,
-        UBShmTransport::S_HELLO_WAIT, UBShmTransport::S_ALLOC_SHM,
-        0, UBShmTransport::S_ACK_WAIT};
     callbacks.fallback_on_not_mine = false;
     callbacks.input = &input;
     HandshakeCodec codec = wire.MakeCodec();
@@ -333,7 +314,7 @@ StepResult UBShmServerHandshakeAdapter::RunUBShmServerHandshake(
                 << remote.toString();
         }
         if (result == STEP_FALLBACK) {
-            transport->_ub_state = UBShmTransport::UB_OFF;
+            transport->DeactivateUpgrade();
         }
         return result;
     };
@@ -346,9 +327,9 @@ StepResult UBShmServerHandshakeAdapter::RunUBShmServerHandshake(
             enabled, len, enabled ? remote.shm_name : NULL, payload);
     };
     callbacks.codecs.push_back(codec);
-    callbacks.prepare_resources = [&]() {
+    callbacks.transport.prepare_resources = [&]() {
         if (!ubring::IsUBAvailable()) {
-            transport->_ub_state = UBShmTransport::UB_OFF;
+            transport->DeactivateUpgrade();
             return STEP_FALLBACK;
         }
         ubring::SHM remote_trx_shm = {
@@ -373,37 +354,37 @@ StepResult UBShmServerHandshakeAdapter::RunUBShmServerHandshake(
             local_trx_shm.name, SHM_MAX_NAME_BUFF_LEN, "%s_%s",
             client_name, SERVER_SHM_NAME_SUFFIX);
         if (UNLIKELY(result < 0)) {
-            transport->_ub_state = UBShmTransport::UB_OFF;
+            transport->DeactivateUpgrade();
             return STEP_FALLBACK;
         }
-        if (ep->AllocateServerResources(
+        if (transport->PrepareServerUpgradeResources(
                 &remote_trx_shm, &local_trx_shm) < 0) {
             LOG(WARNING)
                 << "Fail to allocate ub resources, fallback to tcp:"
                 << socket->description();
-            transport->_ub_state = UBShmTransport::UB_OFF;
+            transport->DeactivateUpgrade();
             return STEP_FALLBACK;
         }
         return STEP_OK;
     };
-    callbacks.negotiate_resources = []() { return STEP_OK; };
+    callbacks.transport.negotiate_resources = []() { return STEP_OK; };
     callbacks.validate_established = [&]() {
         if (!source->empty() ||
-            transport->_ub_state == UBShmTransport::UB_OFF) {
+            !transport->UpgradeActive()) {
             return STEP_ERROR;
         }
         return STEP_OK;
     };
-    callbacks.set_high_speed_active = [transport]() {
-        transport->SetHighSpeedAvailable(true);
+    callbacks.transport.set_high_speed_active = [transport]() {
+        transport->ActivateUpgrade();
     };
-    callbacks.set_tcp_active = [transport]() {
-        transport->SetHighSpeedAvailable(false);
+    callbacks.transport.set_tcp_active = [transport]() {
+        transport->DeactivateUpgrade();
     };
-    callbacks.on_failed = []() {};
+    callbacks.transport.on_failed = []() {};
     const StepResult result = GetSession(socket)->RunServer(callbacks);
     if (result == STEP_OK) {
-        ep->_ub_ring->UbrUnlinkLocalShm();
+        transport->FinishUpgrade();
         LOG_IF(INFO, ubring::FLAGS_ub_trace_verbose)
             << "Server handshake ends (use ubring) on "
             << socket->description();
@@ -416,10 +397,10 @@ StepResult UBShmServerHandshakeAdapter::RunUBShmServerHandshake(
 }
 #endif
 
-StepResult UBShmServerHandshakeAdapter::RunServerHandshake(
+StepResult UBShmServerHandshakeAdapter::RunServerStep(
     butil::IOBuf* source, Socket* socket) {
 #if BRPC_WITH_UBRING
-    if (socket->socket_mode() == SOCKET_MODE_UBRING) {
+    if (AdapterTransport::Get(socket)->upgrade_capable()) {
         return RunUBShmServerHandshake(source, socket);
     }
 #endif
diff --git a/src/brpc/policy/transport_handshake_protocol.cpp b/src/brpc/policy/transport_handshake_protocol.cpp
index bdfefb352e..5d343e0da7 100644
--- a/src/brpc/policy/transport_handshake_protocol.cpp
+++ b/src/brpc/policy/transport_handshake_protocol.cpp
@@ -18,30 +18,14 @@
 #include "brpc/policy/transport_handshake_protocol.h"
 
 #include "butil/logging.h"
-#include "brpc/destroyable.h"
-#include "brpc/handshake/rdma_handshake.h"
-#include "brpc/handshake/ubshm_handshake.h"
-#include "brpc/transport_handshake.h"
+#include "brpc/adapter_transport.h"
 
 namespace brpc {
 namespace policy {
 
 ParseResult ParseTransportHandshake(butil::IOBuf* source, Socket* socket,
                                      bool /*read_eof*/, const void* /*arg*/) {
-    if (socket->parsing_context() != NULL) {
-        handshake::ServerHandshakeContext* context =
-            static_cast<handshake::ServerHandshakeContext*>(
-                socket->parsing_context());
-        CHECK(context->adapter() != NULL);
-        return context->adapter()->ExecuteServerHandshake(source, socket);
-    }
-
-    const char* first = static_cast<const char*>(source->fetch1());
-    handshake::HandshakeAdapter* adapter =
-        first != NULL && *first == 'U'
-        ? handshake::GetUBShmServerHandshakeAdapter()
-        : handshake::GetRdmaServerHandshakeAdapter();
-    return adapter->ExecuteServerHandshake(source, socket);
+    return AdapterTransport::Get(socket)->ProcessUpgradeReadable(source);
 }
 
 void ProcessTransportHandshake(InputMessageBase* msg) {
diff --git a/src/brpc/rdma/rdma_endpoint.h b/src/brpc/rdma/rdma_endpoint.h
index e3937c603a..9d4a57c791 100644
--- a/src/brpc/rdma/rdma_endpoint.h
+++ b/src/brpc/rdma/rdma_endpoint.h
@@ -54,23 +54,6 @@ struct RdmaConnectionInfo {
     butil::optional<ibv_ece> ece;
 };
 
-class RdmaConnect : public AppConnect {
-public:
-    void StartConnect(const Socket* socket, 
-            void (*done)(int err, void* data), void* data) override;
-    void StopConnect(Socket*) override;
-    struct RunGuard {
-        RunGuard(RdmaConnect* rc) { this_rc = rc; }
-        ~RunGuard() { if (this_rc) this_rc->Run(); }
-        RdmaConnect* this_rc;
-    };
-
-private:
-    void Run();
-    void (*_done)(int, void*){NULL};
-    void* _data{NULL};
-};
-
 struct RdmaResource {
     RdmaResource* next{NULL};
     ibv_qp* qp{NULL};
@@ -86,7 +69,6 @@ struct RdmaResource {
 };
 
 class BAIDU_CACHELINE_ALIGNMENT RdmaEndpoint : public SocketUser {
-friend class RdmaConnect;
 friend class Socket;
 friend class ::brpc::RdmaTransport;
 public:
diff --git a/src/brpc/rdma_transport.cpp b/src/brpc/rdma_transport.cpp
index 70cbbe40b0..15ef340f4c 100644
--- a/src/brpc/rdma_transport.cpp
+++ b/src/brpc/rdma_transport.cpp
@@ -20,7 +20,6 @@
 #include "brpc/rdma_transport.h"
 #include "brpc/adapter_transport.h"
 #include "brpc/event_dispatcher.h"
-#include "brpc/handshake/rdma_handshake.h"
 #include "brpc/rdma/rdma_endpoint.h"
 #include "brpc/rdma/rdma_helper.h"
 
@@ -30,47 +29,6 @@ DECLARE_bool(usercode_in_pthread);
 
 extern SocketVarsCollector *g_vars;
 
-namespace rdma {
-
-DECLARE_bool(rdma_trace_verbose);
-
-void RdmaConnect::StartConnect(const Socket* socket,
-                               void (*done)(int err, void* data),
-                               void* data) {
-    RdmaTransport* transport = RdmaTransport::Get(socket);
-    CHECK(transport->_rdma_ep != NULL);
-    SocketUniquePtr ptr;
-    if (Socket::Address(socket->id(), &ptr) != 0) {
-        return;
-    }
-    if (!IsRdmaAvailable()) {
-        transport->FallbackToTcp();
-        done(0, data);
-        return;
-    }
-    _done = done;
-    _data = data;
-    bthread_t tid;
-    bthread_attr_t attr = BTHREAD_ATTR_NORMAL;
-    bthread_attr_set_name(&attr, "RdmaProcessHandshakeAtClient");
-    if (bthread_start_background(&tid, &attr,
-                                 RdmaTransport::ProcessHandshakeAtClient,
-                                 transport) < 0) {
-        LOG(FATAL) << "Fail to start handshake bthread";
-        Run();
-    } else {
-        ptr.release();
-    }
-}
-
-void RdmaConnect::StopConnect(Socket*) {}
-
-void RdmaConnect::Run() {
-    _done(errno, _data);
-}
-
-}  // namespace rdma
-
 RdmaTransport* RdmaTransport::Get(const Socket* socket) {
     const AdapterTransport* adapter = AdapterTransport::Get(socket);
     Transport* transport = adapter->high_speed_transport();
@@ -78,94 +36,6 @@ RdmaTransport* RdmaTransport::Get(const Socket* socket) {
     return static_cast<RdmaTransport*>(transport);
 }
 
-AdapterTransport* RdmaTransport::adapter_transport() const {
-    return AdapterTransport::Get(_socket);
-}
-
-handshake::HandshakeSession* RdmaTransport::handshake_session() const {
-    return adapter_transport()->handshake_session();
-}
-
-int RdmaTransport::handshake_phase() const {
-    return adapter_transport()->handshake_phase();
-}
-
-int RdmaTransport::handshake_version() const {
-    return adapter_transport()->handshake_version();
-}
-
-void RdmaTransport::FallbackToTcp() {
-    adapter_transport()->FallbackToTcp();
-}
-
-void* RdmaTransport::ProcessHandshakeAtClient(void* arg) {
-    RdmaTransport* transport = static_cast<RdmaTransport*>(arg);
-    rdma::RdmaEndpoint* ep = transport->_rdma_ep;
-    SocketUniquePtr socket(transport->_socket);
-    rdma::RdmaConnect::RunGuard guard(
-        static_cast<rdma::RdmaConnect*>(socket->_app_connect.get()));
-
-    LOG_IF(INFO, rdma::FLAGS_rdma_trace_verbose)
-        << "Start handshake on " << socket->description();
-
-    std::unique_ptr<rdma::RdmaHandshakeAdapter> protocol =
-        rdma::CreateClientHandshakeAdapter(ep);
-    CHECK(protocol != NULL);
-    rdma::ParsedHello remote{};
-
-    handshake::ClientHandshakeCallbacks callbacks{};
-    callbacks.phases = handshake::HandshakePhases{
-        C_ALLOC_QPCQ, C_HELLO_SEND, C_HELLO_WAIT,
-        C_BRINGUP_QP, C_ACK_SEND, 0};
-    callbacks.codec = protocol->MakeCodec(&remote);
-    callbacks.prepare_resources = [&]() {
-        if (ep->AllocateResources() == 0) {
-            return handshake::STEP_OK;
-        }
-        PLOG(WARNING) << "Fail to allocate rdma resources, fallback to tcp:"
-                      << socket->description();
-        // Resource preparation is transactional (see #3424): partial RDMA
-        // resources are cleaned by AllocateResources and TCP remains usable.
-        errno = 0;
-        return handshake::STEP_FALLBACK;
-    };
-    callbacks.negotiate_resources = [&]() {
-        ep->ApplyRemoteInfo(remote);
-        if (ep->BringUpQp(remote, false) == 0) {
-            return handshake::STEP_OK;
-        }
-        LOG(WARNING) << "Fail to bringup QP, fallback to tcp:"
-                     << socket->description();
-        return handshake::STEP_FALLBACK;
-    };
-    callbacks.set_high_speed_active = [transport]() {
-        transport->SetHighSpeedAvailable(true);
-    };
-    callbacks.set_tcp_active = [transport]() {
-        transport->SetHighSpeedAvailable(false);
-    };
-    callbacks.on_failed = [&]() {
-        const int saved_errno = errno != 0 ? errno : EPROTO;
-        socket->SetFailed(saved_errno,
-                          "Fail to complete rdma handshake from %s: %s",
-                          socket->description().c_str(), berror(saved_errno));
-    };
-
-    const handshake::StepResult result =
-        transport->handshake_session()->RunClient(callbacks);
-    if (result == handshake::STEP_OK) {
-        LOG_IF(INFO, rdma::FLAGS_rdma_trace_verbose)
-            << "Client handshake ends (use rdma v"
-            << transport->handshake_version() << ") on "
-            << socket->description();
-    } else if (result == handshake::STEP_FALLBACK) {
-        LOG_IF(INFO, rdma::FLAGS_rdma_trace_verbose)
-            << "Client handshake ends (use tcp) on " << socket->description();
-    }
-    errno = 0;
-    return NULL;
-}
-
 void RdmaTransport::Init(Socket *socket, const SocketOptions &options) {
     CHECK(_rdma_ep == NULL);
     _socket = socket;
@@ -198,9 +68,6 @@ int RdmaTransport::Reset(int32_t expected_nref) {
 }
 
 std::shared_ptr<AppConnect> RdmaTransport::Connect() {
-    if (_default_connect == nullptr) {
-        return  std::make_shared<rdma::RdmaConnect>();
-    }
     return _default_connect;
 }
 
@@ -208,6 +75,34 @@ void RdmaTransport::SetHighSpeedAvailable(bool available) {
     _rdma_state = available ? RDMA_ON : RDMA_OFF;
 }
 
+int RdmaTransport::PrepareUpgradeResources() {
+    return _rdma_ep->AllocateResources();
+}
+
+int RdmaTransport::NegotiateUpgradeResources(
+    const rdma::RdmaConnectionInfo& remote, bool server) {
+    _rdma_ep->ApplyRemoteInfo(remote);
+    return _rdma_ep->BringUpQp(remote, server);
+}
+
+std::unique_ptr<rdma::RdmaHandshakeAdapter>
+RdmaTransport::CreateClientHandshakeAdapter() {
+    return rdma::CreateClientHandshakeAdapter(_rdma_ep);
+}
+
+std::vector<std::unique_ptr<rdma::RdmaHandshakeAdapter>>
+RdmaTransport::CreateServerHandshakeAdapters() {
+    return rdma::CreateServerHandshakeAdapters(_rdma_ep);
+}
+
+void RdmaTransport::ActivateUpgrade() {
+    SetHighSpeedAvailable(true);
+}
+
+void RdmaTransport::DeactivateUpgrade() {
+    SetHighSpeedAvailable(false);
+}
+
 int RdmaTransport::CutFromIOBuf(butil::IOBuf* buf) {
     butil::IOBuf* data[1] = {buf};
     return static_cast<int>(CutFromIOBufList(data, 1));
@@ -298,25 +193,6 @@ void RdmaTransport::Debug(std::ostream &os) {
     if (_rdma_state == RDMA_ON && _rdma_ep) {
         _rdma_ep->DebugInfo(os);
     }
-    const char* state = "UNKNOWN";
-    switch (handshake_session()->phase(butil::memory_order_relaxed)) {
-    case UNINIT: state = "UNINIT"; break;
-    case C_ALLOC_QPCQ: state = "C_ALLOC_QPCQ"; break;
-    case C_HELLO_SEND: state = "C_HELLO_SEND"; break;
-    case C_HELLO_WAIT: state = "C_HELLO_WAIT"; break;
-    case C_BRINGUP_QP: state = "C_BRINGUP_QP"; break;
-    case C_ACK_SEND: state = "C_ACK_SEND"; break;
-    case S_HELLO_WAIT: state = "S_HELLO_WAIT"; break;
-    case S_ALLOC_QPCQ: state = "S_ALLOC_QPCQ"; break;
-    case S_BRINGUP_QP: state = "S_BRINGUP_QP"; break;
-    case S_HELLO_SEND: state = "S_HELLO_SEND"; break;
-    case S_ACK_WAIT: state = "S_ACK_WAIT"; break;
-    case ESTABLISHED: state = "ESTABLISHED"; break;
-    case FALLBACK_TCP: state = "FALLBACK_TCP"; break;
-    case FAILED: state = "FAILED"; break;
-    }
-    os << "\nhandshake_state=" << state
-       << "\nhandshake_version=" << handshake_version();
 }
 
 int RdmaTransport::ContextInitOrDie(bool serverOrNot, const void* _options) {
diff --git a/src/brpc/rdma_transport.h b/src/brpc/rdma_transport.h
index dcd6c1c45c..313871b6fc 100644
--- a/src/brpc/rdma_transport.h
+++ b/src/brpc/rdma_transport.h
@@ -22,37 +22,16 @@
 #include "brpc/socket.h"
 #include "brpc/channel.h"
 #include "brpc/transport.h"
-#include "brpc/transport_handshake.h"
+#include "brpc/rdma/rdma_endpoint.h"
+#include "brpc/handshake/rdma_handshake.h"
 
 namespace brpc {
 class AdapterTransport;
-namespace handshake {
-class RdmaServerHandshakeAdapter;
-}
 class RdmaTransport : public Transport {
     friend class TransportFactory;
     friend class AdapterTransport;
     friend class rdma::RdmaEndpoint;
-    friend class rdma::RdmaConnect;
-    friend class handshake::RdmaServerHandshakeAdapter;
 public:
-    enum HandshakeState {
-        UNINIT = 0x0,
-        C_ALLOC_QPCQ = 0x1,
-        C_HELLO_SEND = 0x2,
-        C_HELLO_WAIT = 0x3,
-        C_BRINGUP_QP = 0x4,
-        C_ACK_SEND = 0x5,
-        S_HELLO_WAIT = 0x11,
-        S_ALLOC_QPCQ = 0x12,
-        S_BRINGUP_QP = 0x13,
-        S_HELLO_SEND = 0x14,
-        S_ACK_WAIT = 0x15,
-        ESTABLISHED = handshake::ESTABLISHED,
-        FALLBACK_TCP = handshake::FALLBACK_TCP,
-        FAILED = handshake::FAILED
-    };
-
     void Init(Socket* socket, const SocketOptions& options) override;
     void Release() override;
     int Reset(int32_t expected_nref) override;
@@ -73,16 +52,19 @@ class RdmaTransport : public Transport {
         return Get(socket.get());
     }
     static int ContextInitOrDie(bool serverOrNot, const void* _options);
-    int handshake_phase() const;
-    int handshake_version() const;
 
-    // TCP control-plane callbacks. The endpoint is intentionally absent from
-    // these entry points and only participates through resource operations.
-    static void* ProcessHandshakeAtClient(void* arg);
+    // Resource operations consumed by the upper-level handshake coordinator.
+    int PrepareUpgradeResources();
+    int NegotiateUpgradeResources(const rdma::RdmaConnectionInfo& remote,
+                                  bool server);
+    std::unique_ptr<rdma::RdmaHandshakeAdapter>
+    CreateClientHandshakeAdapter();
+    std::vector<std::unique_ptr<rdma::RdmaHandshakeAdapter>>
+    CreateServerHandshakeAdapters();
+    void ActivateUpgrade();
+    void DeactivateUpgrade();
+    bool UpgradeActive() const { return _rdma_state == RDMA_ON; }
 private:
-    AdapterTransport* adapter_transport() const;
-    handshake::HandshakeSession* handshake_session() const;
-    void FallbackToTcp();
     void SetHighSpeedAvailable(bool available);
 
     static bool OptionsAvailableForRdma(const ChannelOptions* opt);
diff --git a/src/brpc/socket.h b/src/brpc/socket.h
index b5e8a76787..d73ad22956 100644
--- a/src/brpc/socket.h
+++ b/src/brpc/socket.h
@@ -55,11 +55,9 @@ class ChannelBalancer;
 }
 namespace rdma {
 class RdmaEndpoint;
-class RdmaConnect;
 }
 namespace ubring {
     class UBShmEndpoint;
-    class UBConnect;
 }
 namespace handshake {
 class SocketHandshakeIO;
@@ -326,9 +324,7 @@ friend class policy::ConsistentHashingLoadBalancer;
 friend class policy::RtmpContext;
 friend class schan::ChannelBalancer;
 friend class rdma::RdmaEndpoint;
-friend class rdma::RdmaConnect;
 friend class ubring::UBShmEndpoint;
-friend class ubring::UBConnect;
 friend class UBShmTransport;
 friend class HealthCheckTask;
 friend class OnAppHealthCheckDone;
diff --git a/src/brpc/transport_handshake.cpp b/src/brpc/transport_handshake.cpp
index b351c01864..1897b40a2a 100644
--- a/src/brpc/transport_handshake.cpp
+++ b/src/brpc/transport_handshake.cpp
@@ -170,62 +170,62 @@ StepResult HandshakeSession::SelectAndReceiveHello(
 
 StepResult HandshakeSession::RunClient(
     const ClientHandshakeCallbacks& callbacks) {
-    CHECK(callbacks.prepare_resources);
-    CHECK(callbacks.negotiate_resources);
-    CHECK(callbacks.set_high_speed_active);
-    CHECK(callbacks.set_tcp_active);
+    CHECK(callbacks.transport.prepare_resources);
+    CHECK(callbacks.transport.negotiate_resources);
+    CHECK(callbacks.transport.set_high_speed_active);
+    CHECK(callbacks.transport.set_tcp_active);
 
-    SetPhase(callbacks.phases.prepare_local);
-    StepResult result = callbacks.prepare_resources();
+    SetPhase(PREPARING);
+    StepResult result = callbacks.transport.prepare_resources();
     if (result == STEP_FALLBACK) {
-        return FinishWithFallback(this, callbacks.set_tcp_active);
+        return FinishWithFallback(this, callbacks.transport.set_tcp_active);
     }
     if (result != STEP_OK) {
-        return FinishWithFailure(this, callbacks.on_failed);
+        return FinishWithFailure(this, callbacks.transport.on_failed);
     }
 
-    SetPhase(callbacks.phases.hello_send);
+    SetPhase(HELLO_SEND);
     if (SendHello(callbacks.codec, true) != STEP_OK) {
-        return FinishWithFailure(this, callbacks.on_failed);
+        return FinishWithFailure(this, callbacks.transport.on_failed);
     }
 
-    SetPhase(callbacks.phases.hello_wait);
+    SetPhase(HELLO_WAIT);
     result = ReceiveHello(callbacks.codec, NULL, false);
     if (result == STEP_ERROR || result == STEP_NOT_MINE ||
         result == STEP_NEED_MORE) {
-        return FinishWithFailure(this, callbacks.on_failed);
+        return FinishWithFailure(this, callbacks.transport.on_failed);
     }
     bool enabled = result == STEP_OK;
 
     if (enabled) {
-        SetPhase(callbacks.phases.negotiate);
-        result = callbacks.negotiate_resources();
+        SetPhase(NEGOTIATING);
+        result = callbacks.transport.negotiate_resources();
         if (result != STEP_OK && result != STEP_FALLBACK) {
-            return FinishWithFailure(this, callbacks.on_failed);
+            return FinishWithFailure(this, callbacks.transport.on_failed);
         }
         enabled = result == STEP_OK;
     }
 
-    SetPhase(callbacks.phases.ack_send);
+    SetPhase(ACK_SEND);
     if (SendAck(callbacks.codec, enabled) != STEP_OK) {
-        return FinishWithFailure(this, callbacks.on_failed);
+        return FinishWithFailure(this, callbacks.transport.on_failed);
     }
 
     if (enabled) {
-        callbacks.set_high_speed_active();
+        callbacks.transport.set_high_speed_active();
         MarkEstablished();
         return STEP_OK;
     }
-    return FinishWithFallback(this, callbacks.set_tcp_active);
+    return FinishWithFallback(this, callbacks.transport.set_tcp_active);
 }
 
 StepResult HandshakeSession::RunServer(
     const ServerHandshakeCallbacks& callbacks) {
     CHECK(!callbacks.codecs.empty());
-    CHECK(callbacks.prepare_resources);
-    CHECK(callbacks.negotiate_resources);
-    CHECK(callbacks.set_high_speed_active);
-    CHECK(callbacks.set_tcp_active);
+    CHECK(callbacks.transport.prepare_resources);
+    CHECK(callbacks.transport.negotiate_resources);
+    CHECK(callbacks.transport.set_high_speed_active);
+    CHECK(callbacks.transport.set_tcp_active);
 
     // Once TCP fallback has been published, subsequent bytes are application
     // protocol data and must bypass every upgrade codec without changing the
@@ -235,16 +235,16 @@ StepResult HandshakeSession::RunServer(
     }
 
     const HandshakeCodec* selected = NULL;
-    if (phase() != callbacks.phases.ack_wait) {
+    if (phase() != ACK_WAIT) {
         const int previous_phase = phase();
         _local_enabled = false;
-        SetPhase(callbacks.phases.hello_wait);
+        SetPhase(HELLO_WAIT);
         StepResult result = SelectAndReceiveHello(
             callbacks.codecs, callbacks.input,
             callbacks.fallback_on_not_mine, &selected);
         if (result == STEP_NOT_MINE) {
             if (callbacks.fallback_on_not_mine) {
-                return FinishWithFallback(this, callbacks.set_tcp_active);
+                return FinishWithFallback(this, callbacks.transport.set_tcp_active);
             }
             SetPhase(UNINITIALIZED);
             return STEP_NOT_MINE;
@@ -256,35 +256,35 @@ StepResult HandshakeSession::RunServer(
             return STEP_NEED_MORE;
         }
         if (result == STEP_ERROR) {
-            return FinishWithFailure(this, callbacks.on_failed);
+            return FinishWithFailure(this, callbacks.transport.on_failed);
         }
         bool enabled = result == STEP_OK;
 
         if (enabled) {
-            SetPhase(callbacks.phases.prepare_local);
-            result = callbacks.prepare_resources();
+            SetPhase(PREPARING);
+            result = callbacks.transport.prepare_resources();
             if (result != STEP_OK && result != STEP_FALLBACK) {
-                return FinishWithFailure(this, callbacks.on_failed);
+                return FinishWithFailure(this, callbacks.transport.on_failed);
             }
             enabled = result == STEP_OK;
         }
 
         if (enabled) {
-            SetPhase(callbacks.phases.negotiate);
-            result = callbacks.negotiate_resources();
+            SetPhase(NEGOTIATING);
+            result = callbacks.transport.negotiate_resources();
             if (result != STEP_OK && result != STEP_FALLBACK) {
-                return FinishWithFailure(this, callbacks.on_failed);
+                return FinishWithFailure(this, callbacks.transport.on_failed);
             }
             enabled = result == STEP_OK;
         }
 
-        SetPhase(callbacks.phases.hello_send);
+        SetPhase(HELLO_SEND);
         CHECK(selected != NULL);
         _local_enabled = enabled;
         if (SendHello(*selected, enabled) != STEP_OK) {
-            return FinishWithFailure(this, callbacks.on_failed);
+            return FinishWithFailure(this, callbacks.transport.on_failed);
         }
-        SetPhase(callbacks.phases.ack_wait);
+        SetPhase(ACK_WAIT);
     } else {
         for (size_t i = 0; i < callbacks.codecs.size(); ++i) {
             if (callbacks.codecs[i].protocol_version == protocol_version()) {
@@ -306,24 +306,24 @@ StepResult HandshakeSession::RunServer(
         return STEP_NEED_MORE;
     }
     if (result == STEP_ERROR || result == STEP_NOT_MINE) {
-        return FinishWithFailure(this, callbacks.on_failed);
+        return FinishWithFailure(this, callbacks.transport.on_failed);
     }
     if (result == STEP_FALLBACK) {
-        return FinishWithFallback(this, callbacks.set_tcp_active);
+        return FinishWithFallback(this, callbacks.transport.set_tcp_active);
     }
     if (!peer_enabled) {
-        return FinishWithFallback(this, callbacks.set_tcp_active);
+        return FinishWithFallback(this, callbacks.transport.set_tcp_active);
     }
     if (!_local_enabled) {
         errno = EPROTO;
-        return FinishWithFailure(this, callbacks.on_failed);
+        return FinishWithFailure(this, callbacks.transport.on_failed);
     }
     if (callbacks.validate_established &&
         callbacks.validate_established() != STEP_OK) {
-        return FinishWithFailure(this, callbacks.on_failed);
+        return FinishWithFailure(this, callbacks.transport.on_failed);
     }
 
-    callbacks.set_high_speed_active();
+    callbacks.transport.set_high_speed_active();
     MarkEstablished();
     return STEP_OK;
 }
diff --git a/src/brpc/transport_handshake.h b/src/brpc/transport_handshake.h
index cc206dee62..3899a3aa44 100644
--- a/src/brpc/transport_handshake.h
+++ b/src/brpc/transport_handshake.h
@@ -54,7 +54,12 @@ struct ServerHandshakeContext : public Destroyable {
 // acquire-side decision for RDMA, URMA and UBSHM.
 enum Phase {
     UNINITIALIZED = 0,
-    NEGOTIATING = 1,
+    PREPARING = 1,
+    HELLO_SEND = 2,
+    HELLO_WAIT = 3,
+    NEGOTIATING = 4,
+    ACK_SEND = 5,
+    ACK_WAIT = 6,
     ESTABLISHED = 0x100,
     FALLBACK_TCP = 0x200,
     FAILED = 0x300,
@@ -68,15 +73,6 @@ enum StepResult {
     STEP_ERROR,
 };
 
-struct HandshakePhases {
-    int prepare_local;
-    int hello_send;
-    int hello_wait;
-    int negotiate;
-    int ack_send;
-    int ack_wait;
-};
-
 // A protocol describes only its fields and resource-independent wire values.
 // HandshakeSession owns framing and I/O through FrameCodec. The callbacks may
 // retain strongly typed parsed state in their protocol adapter.
@@ -90,11 +86,10 @@ struct HandshakeCodec {
     std::function<StepResult(const std::string&, bool*)> parse_ack;
 };
 
-// Resource-specific operations invoked by the common client driver. Wire I/O
-// and field codec invocation are owned by HandshakeSession.
-struct ClientHandshakeCallbacks {
-    HandshakePhases phases;
-    HandshakeCodec codec;
+// Resource-specific operations supplied by a Transport and invoked by the
+// common coordinator. Wire I/O and field codec invocation remain owned by
+// HandshakeSession.
+struct TransportUpgradeOps {
     std::function<StepResult()> prepare_resources;
     std::function<StepResult()> negotiate_resources;
     std::function<void()> set_high_speed_active;
@@ -102,21 +97,21 @@ struct ClientHandshakeCallbacks {
     std::function<void()> on_failed;
 };
 
+struct ClientHandshakeCallbacks {
+    HandshakeCodec codec;
+    TransportUpgradeOps transport;
+};
+
 // The server driver is independent of the input mode. A parser callback can
 // return STEP_NEED_MORE, while a blocking callback waits before returning.
 struct ServerHandshakeCallbacks {
-    HandshakePhases phases;
     bool fallback_on_not_mine;
     // Buffered parsers may offer multiple codecs (RDMA v2/v3). Blocking
     // server handshakes currently provide exactly one codec.
     std::vector<HandshakeCodec> codecs;
     HandshakeInput* input;
-    std::function<StepResult()> prepare_resources;
-    std::function<StepResult()> negotiate_resources;
+    TransportUpgradeOps transport;
     std::function<StepResult()> validate_established;
-    std::function<void()> set_high_speed_active;
-    std::function<void()> set_tcp_active;
-    std::function<void()> on_failed;
 };
 
 // Owns one connection-upgrade attempt, invokes the protocol field codec and
diff --git a/src/brpc/ubshm/ub_endpoint.h b/src/brpc/ubshm/ub_endpoint.h
index e018d30b44..29fc5b8470 100644
--- a/src/brpc/ubshm/ub_endpoint.h
+++ b/src/brpc/ubshm/ub_endpoint.h
@@ -45,25 +45,7 @@ DECLARE_int32(ub_poller_num);
 DECLARE_bool(ub_edisp_unsched);
 DECLARE_bool(ub_disable_bthread);
 
-class UBConnect : public AppConnect {
-public:
-    void StartConnect(const Socket* socket,
-            void (*done)(int err, void* data), void* data) override;
-    void StopConnect(Socket*) override;
-    struct RunGuard {
-        RunGuard(UBConnect* rc) { this_rc = rc; }
-        ~RunGuard() { if (this_rc) this_rc->Run(); }
-        UBConnect* this_rc;
-    };
-
-private:
-    void Run();
-    void (*_done)(int, void*){NULL};
-    void* _data{NULL};
-};
-
 class BAIDU_CACHELINE_ALIGNMENT UBShmEndpoint : public SocketUser {
-friend class UBConnect;
 friend class Socket;
 friend class ::brpc::UBShmTransport;
 friend class ::brpc::handshake::UBShmServerHandshakeAdapter;
diff --git a/src/brpc/ubshm_transport.cpp b/src/brpc/ubshm_transport.cpp
index f6c99ab2a9..42eef2036a 100644
--- a/src/brpc/ubshm_transport.cpp
+++ b/src/brpc/ubshm_transport.cpp
@@ -22,7 +22,6 @@
 #include "brpc/ubshm_transport.h"
 #include "brpc/adapter_transport.h"
 #include "brpc/errno.pb.h"
-#include "brpc/handshake/ubshm_handshake.h"
 #include "brpc/ubshm/common/common.h"
 #include "brpc/ubshm/ub_endpoint.h"
 #include "brpc/ubshm/ub_helper.h"
@@ -34,45 +33,6 @@ DECLARE_bool(usercode_in_pthread);
 
 extern SocketVarsCollector *g_vars;
 
-namespace ubring {
-
-void UBConnect::StartConnect(const Socket* socket,
-                             void (*done)(int err, void* data),
-                             void* data) {
-    UBShmTransport* transport = UBShmTransport::Get(socket);
-    CHECK(transport->_ub_ep != NULL);
-    SocketUniquePtr ptr;
-    if (Socket::Address(socket->id(), &ptr) != 0) {
-        return;
-    }
-    if (!IsUBAvailable()) {
-        transport->FallbackToTcp();
-        done(0, data);
-        return;
-    }
-    _done = done;
-    _data = data;
-    bthread_t tid;
-    bthread_attr_t attr = BTHREAD_ATTR_NORMAL;
-    bthread_attr_set_name(&attr, "UBProcessHandshakeAtClient");
-    if (bthread_start_background(
-            &tid, &attr, UBShmTransport::ProcessHandshakeAtClient,
-            transport) < 0) {
-        LOG(FATAL) << "Fail to start handshake bthread";
-        Run();
-    } else {
-        ptr.release();
-    }
-}
-
-void UBConnect::StopConnect(Socket*) {}
-
-void UBConnect::Run() {
-    _done(errno, _data);
-}
-
-}  // namespace ubring
-
 UBShmTransport* UBShmTransport::Get(const Socket* socket) {
     const AdapterTransport* adapter = AdapterTransport::Get(socket);
     Transport* transport = adapter->high_speed_transport();
@@ -80,118 +40,6 @@ UBShmTransport* UBShmTransport::Get(const Socket* socket) {
     return static_cast<UBShmTransport*>(transport);
 }
 
-AdapterTransport* UBShmTransport::adapter_transport() const {
-    return AdapterTransport::Get(_socket);
-}
-
-handshake::HandshakeSession* UBShmTransport::handshake_session() const {
-    return adapter_transport()->handshake_session();
-}
-
-int UBShmTransport::handshake_phase() const {
-    return adapter_transport()->handshake_phase();
-}
-
-int UBShmTransport::handshake_version() const {
-    return adapter_transport()->handshake_version();
-}
-
-void UBShmTransport::FallbackToTcp() {
-    adapter_transport()->FallbackToTcp();
-}
-
-void* UBShmTransport::ProcessHandshakeAtClient(void* arg) {
-    UBShmTransport* transport = static_cast<UBShmTransport*>(arg);
-    ubring::UBShmEndpoint* ep = transport->_ub_ep;
-    SocketUniquePtr socket(ep->_socket);
-    ubring::UBConnect::RunGuard guard(
-        static_cast<ubring::UBConnect*>(socket->_app_connect.get()));
-
-    LOG_IF(INFO, ubring::FLAGS_ub_trace_verbose)
-        << "Start handshake on " << socket->_local_side;
-
-    const size_t local_shm_len =
-        static_cast<size_t>(ubring::FLAGS_data_queue_size) * MB_TO_BYTE;
-    ubring::SHM local_trx_shm = {
-        NULL, local_shm_len, 0, {0},
-        static_cast<uint32_t>(socket->fd())};
-    const auto shm_name_str = butil::endpoint2str(socket->local_side());
-    const char* const shm_name = shm_name_str.c_str();
-    ubring::HelloMessage remote{};
-    ubring::UBShmHandshakeAdapter wire;
-
-    handshake::ClientHandshakeCallbacks callbacks{};
-    callbacks.phases = handshake::HandshakePhases{
-        C_ALLOC_SHM, C_HELLO_SEND, C_HELLO_WAIT,
-        C_MAP_REMOTE_SHM, C_ACK_SEND, 0};
-    callbacks.codec = wire.MakeCodec();
-    callbacks.codec.build_hello = [&](bool enabled, std::string* payload) {
-        CHECK(enabled);
-        const handshake::StepResult result = wire.BuildHello(
-            true, local_shm_len, local_trx_shm.name, payload);
-        if (result == handshake::STEP_OK) {
-            ubring::HelloMessage local{};
-            local.Deserialize(payload->data());
-            LOG_IF(INFO, ubring::FLAGS_ub_trace_verbose)
-                << "client handshake message : " << local.toString();
-        }
-        return result;
-    };
-    callbacks.codec.parse_hello = [&](const std::string& payload) {
-        const handshake::StepResult result = wire.ParseHello(payload, &remote);
-        if (result == handshake::STEP_FALLBACK) {
-            LOG(WARNING)
-                << "Fail to negotiate with server, fallback to tcp:"
-                << socket->description();
-        }
-        return result;
-    };
-    callbacks.prepare_resources = [&]() {
-        if (ep->AllocateClientResources(&local_trx_shm, shm_name) == 0) {
-            return handshake::STEP_OK;
-        }
-        LOG(WARNING) << "Fallback to tcp:" << socket->description();
-        errno = 0;
-        return handshake::STEP_FALLBACK;
-    };
-    callbacks.negotiate_resources = [&]() {
-        if (ep->_ub_ring->UbrMapRemoteShm(
-                &local_trx_shm, shm_name) == 0) {
-            return handshake::STEP_OK;
-        }
-        LOG(WARNING) << "Fail to map the remote shm, fallback to tcp:"
-                     << socket->description();
-        return handshake::STEP_FALLBACK;
-    };
-    callbacks.set_high_speed_active = [transport]() {
-        transport->SetHighSpeedAvailable(true);
-    };
-    callbacks.set_tcp_active = [transport]() {
-        transport->SetHighSpeedAvailable(false);
-    };
-    callbacks.on_failed = [&]() {
-        const int saved_errno = errno != 0 ? errno : EPROTO;
-        socket->SetFailed(saved_errno,
-                          "Fail to complete ubring handshake from %s: %s",
-                          socket->description().c_str(), berror(saved_errno));
-    };
-
-    const handshake::StepResult result =
-        transport->handshake_session()->RunClient(callbacks);
-    if (result == handshake::STEP_OK) {
-        ep->_ub_ring->UbrUnlinkLocalShm();
-        LOG_IF(INFO, ubring::FLAGS_ub_trace_verbose)
-            << "Client handshake ends (use ubring) on "
-            << socket->description();
-    } else if (result == handshake::STEP_FALLBACK) {
-        LOG_IF(INFO, ubring::FLAGS_ub_trace_verbose)
-            << "Client handshake ends (use tcp) on "
-            << socket->description();
-    }
-    errno = 0;
-    return NULL;
-}
-
 void UBShmTransport::Init(Socket *socket, const SocketOptions &options) {
     CHECK(_ub_ep == NULL);
     _socket = socket;
@@ -224,9 +72,6 @@ int UBShmTransport::Reset(int32_t expected_nref) {
 }
 
 std::shared_ptr<AppConnect> UBShmTransport::Connect() {
-    if (_default_connect == nullptr) {
-        return  std::make_shared<ubring::UBConnect>();
-    }
     return _default_connect;
 }
 
@@ -234,6 +79,35 @@ void UBShmTransport::SetHighSpeedAvailable(bool available) {
     _ub_state = available ? UB_ON : UB_OFF;
 }
 
+int UBShmTransport::PrepareUpgradeResources(
+    ubring::SHM* local_trx_shm, const char* shm_name) {
+    return _ub_ep->AllocateClientResources(local_trx_shm, shm_name);
+}
+
+int UBShmTransport::NegotiateUpgradeResources(
+    ubring::SHM* local_trx_shm, const char* shm_name) {
+    return _ub_ep->_ub_ring->UbrMapRemoteShm(local_trx_shm, shm_name);
+}
+
+int UBShmTransport::PrepareServerUpgradeResources(
+    ubring::SHM* remote_trx_shm, ubring::SHM* local_trx_shm) {
+    return _ub_ep->AllocateServerResources(remote_trx_shm, local_trx_shm);
+}
+
+void UBShmTransport::ActivateUpgrade() {
+    SetHighSpeedAvailable(true);
+}
+
+void UBShmTransport::DeactivateUpgrade() {
+    SetHighSpeedAvailable(false);
+}
+
+void UBShmTransport::FinishUpgrade() {
+    if (_ub_ep != NULL && _ub_ep->_ub_ring != NULL) {
+        _ub_ep->_ub_ring->UbrUnlinkLocalShm();
+    }
+}
+
 int UBShmTransport::CutFromIOBuf(butil::IOBuf* buf) {
     butil::IOBuf* data[1] = {buf};
     return static_cast<int>(CutFromIOBufList(data, 1));
diff --git a/src/brpc/ubshm_transport.h b/src/brpc/ubshm_transport.h
index abdd25e069..7407a352a1 100644
--- a/src/brpc/ubshm_transport.h
+++ b/src/brpc/ubshm_transport.h
@@ -21,36 +21,15 @@
 #include "brpc/socket.h"
 #include "brpc/channel.h"
 #include "brpc/transport.h"
-#include "brpc/transport_handshake.h"
+#include "brpc/ubshm/shm/shm_def.h"
 
 namespace brpc {
 class AdapterTransport;
-namespace handshake {
-class UBShmServerHandshakeAdapter;
-}
 class UBShmTransport : public Transport {
     friend class TransportFactory;
     friend class AdapterTransport;
     friend class ubring::UBShmEndpoint;
-    friend class ubring::UBConnect;
-    friend class handshake::UBShmServerHandshakeAdapter;
 public:
-    enum HandshakeState {
-        UNINIT = 0x0,
-        C_ALLOC_SHM = 0x1,
-        C_HELLO_SEND = 0x2,
-        C_HELLO_WAIT = 0x3,
-        C_MAP_REMOTE_SHM = 0x4,
-        C_ACK_SEND = 0x5,
-        S_HELLO_WAIT = 0x11,
-        S_ALLOC_SHM = 0x12,
-        S_HELLO_SEND = 0x13,
-        S_ACK_WAIT = 0x14,
-        ESTABLISHED = handshake::ESTABLISHED,
-        FALLBACK_TCP = handshake::FALLBACK_TCP,
-        FAILED = handshake::FAILED
-    };
-
     void Init(Socket* socket, const SocketOptions& options) override;
     void Release() override;
     int Reset(int32_t expected_nref) override;
@@ -68,13 +47,17 @@ class UBShmTransport : public Transport {
     }
     static UBShmTransport* Get(const Socket* socket);
     static int ContextInitOrDie(bool serverOrNot, const void* _options);
-    int handshake_phase() const;
-    int handshake_version() const;
-    static void* ProcessHandshakeAtClient(void* arg);
+    int PrepareUpgradeResources(ubring::SHM* local_trx_shm,
+                                const char* shm_name);
+    int NegotiateUpgradeResources(ubring::SHM* local_trx_shm,
+                                  const char* shm_name);
+    int PrepareServerUpgradeResources(ubring::SHM* remote_trx_shm,
+                                      ubring::SHM* local_trx_shm);
+    void ActivateUpgrade();
+    void DeactivateUpgrade();
+    void FinishUpgrade();
+    bool UpgradeActive() const { return _ub_state == UB_ON; }
 private:
-    AdapterTransport* adapter_transport() const;
-    handshake::HandshakeSession* handshake_session() const;
-    void FallbackToTcp();
     void SetHighSpeedAvailable(bool available);
 
     static bool OptionsAvailableForUB(const ChannelOptions* opt);
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/01ccfd37e3d64cd110462f1203e0d20642510e3e3d14a570a041257996772a31.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/01ccfd37e3d64cd110462f1203e0d20642510e3e3d14a570a041257996772a31.json
new file mode 100644
index 0000000000..dc93d7be43
--- /dev/null
+++ b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/01ccfd37e3d64cd110462f1203e0d20642510e3e3d14a570a041257996772a31.json
@@ -0,0 +1 @@
+{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_opcode_h", "label": "urma_opcode.h", "file_type": "code", "source_file": "sdk/urma/urma_opcode.h", "source_location": "L1"}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_opcode_h", "target": "errno", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_opcode.h", "source_location": "L14", "weight": 1.0}], "raw_calls": []}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/1df09f4812201fd3151eb13e804615a74b896364be016d8a28ec657f714e1422.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/1df09f4812201fd3151eb13e804615a74b896364be016d8a28ec657f714e1422.json
new file mode 100644
index 0000000000..ebff288857
--- /dev/null
+++ b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/1df09f4812201fd3151eb13e804615a74b896364be016d8a28ec657f714e1422.json
@@ -0,0 +1 @@
+{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_h", "label": "urma_helper.h", "file_type": "code", "source_file": "urma_helper.h", "source_location": "L1"}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_h", "target": "cstddef", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.h", "source_location": "L21", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_h", "target": "cstdint", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.h", "source_location": "L22", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_h", "target": "functional", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.h", "source_location": "L23", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_h", "target": "string", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.h", "source_location": "L24", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_h", "target": "types", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.h", "source_location": "L26", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_h", "target": "atomicops", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.h", "source_location": "L27", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_h", "target": "urma_api", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.h", "source_location": "L31", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_h", "target": "urma_types", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.h", "source_location": "L32", "weight": 1.0}], "raw_calls": []}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/3dcbdee4a792ca85149ae0eada9ea3f39bb1c3f972074cfdeb983ed964bc1f54.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/3dcbdee4a792ca85149ae0eada9ea3f39bb1c3f972074cfdeb983ed964bc1f54.json
new file mode 100644
index 0000000000..4bfad372ec
--- /dev/null
+++ b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/3dcbdee4a792ca85149ae0eada9ea3f39bb1c3f972074cfdeb983ed964bc1f54.json
@@ -0,0 +1 @@
+{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "label": "urma_handshake.cpp", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L1"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "label": "HelloMessage::Serialize()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L72", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "label": "HelloMessage::Deserialize()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L91", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_validhello", "label": "ValidHello()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L127", "_callable": true}, {"id": "parsedhello", "label": "ParsedHello", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_handshake.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "label": "ReadBodyAndNegotiate()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L141", "_callable": true}, {"id": "urmaendpoint", "label": "UrmaEndpoint", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_handshake.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_drainbytes", "label": "DrainBytes()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L173", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_sendlocalhello", "label": "UrmaHandshakeClientV2::SendLocalHello()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L187", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_receiveandparseremotehello", "label": "UrmaHandshakeClientV2::ReceiveAndParseRemoteHello()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L196", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_receiveandparseremotehello", "label": "UrmaHandshakeServerV2::ReceiveAndParseRemoteHello()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L210", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "label": "UrmaHandshakeServerV2::SendLocalHello()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L215", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_sendlocalhello", "label": "UrmaHandshakeClientV3::SendLocalHello()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L240", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_receiveandparseremotehello", "label": "UrmaHandshakeClientV3::ReceiveAndParseRemoteHello()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L246", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_receiveandparseremotehello", "label": "UrmaHandshakeServerV3::ReceiveAndParseRemoteHello()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L258", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_sendlocalhello", "label": "UrmaHandshakeServerV3::SendLocalHello()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L263", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createclienthandshake", "label": "CreateClientHandshake()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L274", "_callable": true}, {"id": "urmahandshake", "label": "UrmaHandshake", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_handshake.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createserverhandshakebymagic", "label": "CreateServerHandshakeByMagic()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L282", "_callable": true}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "urma_handshake", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L18", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "algorithm", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L22", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "cstring", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L23", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "limits", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L24", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "gflags", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L26", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "atomicops", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L28", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "iobuf", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L29", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "logging", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L30", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "sys_byteorder", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L31", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "socket", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L33", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "urma_endpoint", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L34", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "urma_helper", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L35", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "urma_handshake", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L36", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "urma_transport", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L37", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L72", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L91", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_validhello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L127", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_validhello", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L127", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L141", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "target": "urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L141", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L141", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_drainbytes", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L173", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_drainbytes", "target": "urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L173", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_sendlocalhello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L187", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_receiveandparseremotehello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L196", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_receiveandparseremotehello", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L196", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_receiveandparseremotehello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L210", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_receiveandparseremotehello", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L210", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L215", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_sendlocalhello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L240", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_receiveandparseremotehello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L246", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_receiveandparseremotehello", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L246", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_receiveandparseremotehello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L258", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_receiveandparseremotehello", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L258", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_sendlocalhello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L263", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createclienthandshake", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L274", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createclienthandshake", "target": "urmahandshake", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L274", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createclienthandshake", "target": "urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L274", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createserverhandshakebymagic", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L282", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createserverhandshakebymagic", "target": "urmahandshake", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L282", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createserverhandshakebymagic", "target": "urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L282", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_validhello", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L163", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_drainbytes", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L166", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_receiveandparseremotehello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L207", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_receiveandparseremotehello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L212", "weight": 1.0}], "raw_calls": [{"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet16", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L74", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet16", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L75", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet16", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L76", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L77", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L78", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L79", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "memcpy", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L80", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L81", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "memset", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L83", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "memcpy", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L84", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L85", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet64", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L86", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet64", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L87", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L88", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost16", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L93", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost16", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L94", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost16", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L95", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L96", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L97", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L98", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "memcpy", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L99", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L100", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "memcpy", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L103", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L104", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost64", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L105", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost64", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L106", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L107", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "callee": "ReadFromFd", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L144", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "callee": "Deserialize", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L146", "receiver": "m", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "callee": "memcpy", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L155", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "callee": "memcpy", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L158", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_drainbytes", "callee": "ReadFromFd", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L177", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_sendlocalhello", "callee": "FillLocalHelloV2", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L189", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_sendlocalhello", "callee": "memcpy", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L191", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_sendlocalhello", "callee": "Serialize", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L192", "receiver": "m", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_sendlocalhello", "callee": "WriteToFd", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L193", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_receiveandparseremotehello", "callee": "ReadFromFd", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L200", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_receiveandparseremotehello", "callee": "memcmp", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L201", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_receiveandparseremotehello", "callee": "PushBackToReadBuf", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L204", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "callee": "FillLocalHelloV2", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L217", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "callee": "get", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L218", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "callee": "load", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L219", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "callee": "memcpy", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L229", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "callee": "Serialize", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L230", "receiver": "m", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "callee": "WriteToFd", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L231", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_sendlocalhello", "callee": "FillLocalHelloV3", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L242", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_sendlocalhello", "callee": "WriteHelloV3", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L243", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_receiveandparseremotehello", "callee": "ReadFromFd", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L250", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_receiveandparseremotehello", "callee": "memcmp", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L251", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_receiveandparseremotehello", "callee": "PushBackToReadBuf", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L252", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_receiveandparseremotehello", "callee": "ReadAndParseHelloV3", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L255", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_receiveandparseremotehello", "callee": "ReadAndParseHelloV3", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L260", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_sendlocalhello", "callee": "FillLocalHelloV3", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L265", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_sendlocalhello", "callee": "WriteHelloV3", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L267", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createserverhandshakebymagic", "callee": "memcmp", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L284", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createserverhandshakebymagic", "callee": "memcmp", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L287", "receiver": null, "lang": "cpp"}], "cpp_type_table": {"path": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_handshake.cpp", "table": {"p": "ParsedHello", "m": "HelloMessage", "msg": "UrmaHello"}}}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/5af18e30c1f05aae06e4f45bf09d4d6ab3654daf64631c4821071a362adf2f1e.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/5af18e30c1f05aae06e4f45bf09d4d6ab3654daf64631c4821071a362adf2f1e.json
new file mode 100644
index 0000000000..9e5c46ae91
--- /dev/null
+++ b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/5af18e30c1f05aae06e4f45bf09d4d6ab3654daf64631c4821071a362adf2f1e.json
@@ -0,0 +1 @@
+{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "label": "urma_helper.cpp", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L1"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg", "label": "UserSeg", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L139", "_callable": true}, {"id": "urma_target_seg_t", "label": "urma_target_seg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg_tseg", "label": "tseg", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L140"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg_base", "label": "base", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L141"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg_len", "label": "len", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L142"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pagesize", "label": "PageSize()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L155", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_alignup", "label": "AlignUp()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L160", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "label": "BufferPool", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L174", "_callable": true}, {"id": "mutex", "label": "Mutex", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_mutexes", "label": "mutexes", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L175"}, {"id": "vector", "label": "vector", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_free_lists", "label": "free_lists", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L176"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_in_use", "label": "in_use", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L177"}, {"id": "atomic", "label": "atomic", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_outstanding", "label": "outstanding", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L178"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_buffer_count", "label": ".buffer_count()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L180", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_shardfor", "label": "ShardFor()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L186", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_preferredshard", "label": "PreferredShard()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L193", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "label": "PoolAllocate()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L200", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "label": "PoolDeallocate()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L227", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "label": "InitPool()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L259", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_getpoolsegfor", "label": "GetPoolSegFor()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L313", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "label": "GlobalRelease()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L324", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "label": "GlobalUrmaInitializeImpl()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L372", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "label": "GlobalUrmaInitializeOrDie()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L521", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_isurmaavailable", "label": "IsUrmaAvailable()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L540", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globaldisableurma", "label": "GlobalDisableUrma()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L544", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_supportedbyurma", "label": "SupportedByUrma()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L548", "_callable": true}, {"id": "string", "label": "string", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_geturmacontext", "label": "GetUrmaContext()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L552", "_callable": true}, {"id": "urma_context_t", "label": "urma_context_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_geturmamaxsge", "label": "GetUrmaMaxSge()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L553", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_geturmarecvblocksize", "label": "GetUrmaRecvBlockSize()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L554", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "label": "InitPollingModeWithTag()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L560", "_callable": true}, {"id": "bthread_tag_t", "label": "bthread_tag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp"}, {"id": "function", "label": "function", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_releasepollingmodewithtag", "label": "ReleasePollingModeWithTag()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L570", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_registermemoryforurma", "label": "RegisterMemoryForUrma()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L578", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_deregistermemoryforurma", "label": "DeregisterMemoryForUrma()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L613", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_getseghandle", "label": "GetSegHandle()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L622", "_callable": true}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "urma_helper", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L18", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "errno", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L22", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "pthread", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L23", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "stdlib", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L24", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "string", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L25", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "mman", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L26", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "unistd", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L27", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "atomic", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L29", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "new", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L30", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "utility", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L31", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "vector", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L32", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "gflags", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L34", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "atomicops", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L36", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "flat_map", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L37", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "iobuf", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L38", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "logging", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L39", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "macros", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L40", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "scoped_lock", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L41", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "lock", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L42", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "urma_api", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L44", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "urma_types", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L45", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "urma_endpoint", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L46", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L139", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L140", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg_tseg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L140", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg_base", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L141", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L142", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pagesize", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L155", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_alignup", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L160", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L174", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "target": "mutex", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L175", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_mutexes", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L175", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "target": "vector", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L176", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_free_lists", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L176", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "target": "vector", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L177", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_in_use", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L177", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "target": "atomic", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L178", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_outstanding", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L178", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_buffer_count", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L180", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_shardfor", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L186", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_preferredshard", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L193", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L200", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L227", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L259", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_getpoolsegfor", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L313", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_getpoolsegfor", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L313", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L324", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L372", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L521", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_isurmaavailable", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L540", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globaldisableurma", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L544", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_supportedbyurma", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L548", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_supportedbyurma", "target": "string", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L548", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_geturmacontext", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L552", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_geturmacontext", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L552", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_geturmamaxsge", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L553", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_geturmarecvblocksize", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L554", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L560", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "target": "bthread_tag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L560", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "target": "function", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L560", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "target": "function", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L560", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "target": "function", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L560", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_releasepollingmodewithtag", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L570", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_releasepollingmodewithtag", "target": "bthread_tag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L570", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_registermemoryforurma", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L578", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_deregistermemoryforurma", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L613", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_getseghandle", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L622", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "cstdlib", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L653", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "logging", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L655", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L660", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_preferredshard", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L209", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_shardfor", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L242", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_buffer_count", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L261", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pagesize", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L264", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_alignup", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L265", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "target": "string", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L414", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L485", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_buffer_count", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L514", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L527", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L529", "weight": 1.0}], "raw_calls": [{"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pagesize", "callee": "sysconf", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L156", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_buffer_count", "callee": "size", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L181", "receiver": "in_use", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_preferredshard", "callee": "pthread_self", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L196", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "BAIDU_UNLIKELY", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L201", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "g_mem_alloc_orig", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L202", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "malloc", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L202", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "g_mem_alloc_orig", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L207", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "malloc", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L207", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "BAIDU_SCOPED_LOCK", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L212", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "empty", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L214", "receiver": "fl", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "back", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L215", "receiver": "fl", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "pop_back", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L216", "receiver": "fl", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "size", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L219", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "fetch_add", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L220", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L223", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "g_mem_alloc_orig", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L224", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "malloc", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L224", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "BAIDU_UNLIKELY", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L228", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "g_mem_dealloc_orig", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L229", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "free", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L230", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "g_mem_dealloc_orig", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L238", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "free", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L239", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "BAIDU_SCOPED_LOCK", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L243", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "size", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L245", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L247", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "push_back", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L252", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "load", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L253", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "fetch_sub", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L254", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "callee": "mmap", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L267", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "callee": "PLOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L270", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "callee": "urma_register_seg", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L290", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "callee": "PLOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L292", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "callee": "munmap", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L293", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "callee": "assign", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L297", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "callee": "push_back", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L300", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L303", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "callee": "store", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L325", "receiver": "g_urma_available", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "callee": "SetDefaultBlockSize", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L335", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "callee": "GlobalRelease", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L338", "receiver": "UrmaEndpoint", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "callee": "urma_unregister_seg", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L340", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "callee": "munmap", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L344", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "callee": "urma_delete_context", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L355", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "callee": "urma_uninit", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L359", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L361", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "BAIDU_UNLIKELY", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L373", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "store", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L374", "receiver": "g_urma_available", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L381", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_init", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L387", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L390", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L398", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_get_device_list", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L405", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L407", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_free_device_list", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L408", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "empty", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L413", "receiver": "FLAGS_urma_device", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L420", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_free_device_list", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L421", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_query_device", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L427", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L428", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_free_device_list", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L429", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_get_eid_list", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L434", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L436", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_free_eid_list", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L437", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_free_device_list", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L438", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_create_context", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L442", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_free_eid_list", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L443", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_free_device_list", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L444", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L447", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L457", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "init", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L471", "receiver": "g_user_segs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L472", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "assign", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L481", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "reserve", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L483", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L486", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "GetDefaultBlockSize", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L495", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "SetDefaultBlockSize", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L498", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "GlobalInitialize", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L500", "receiver": "UrmaEndpoint", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L501", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "store", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L505", "receiver": "g_urma_available", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L511", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "callee": "load", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L523", "receiver": "g_init_once", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "callee": "compare_exchange_strong", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L524", "receiver": "g_init_once", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "callee": "BAIDU_SCOPED_LOCK", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L526", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L528", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "callee": "store", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L531", "receiver": "g_init_once", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "callee": "load", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L534", "receiver": "g_init_once", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_isurmaavailable", "callee": "load", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L541", "receiver": "g_urma_available", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globaldisableurma", "callee": "store", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L545", "receiver": "g_urma_available", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "callee": "BAIDU_UNLIKELY", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L564", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "callee": "PollingModeInitialize", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L565", "receiver": "UrmaEndpoint", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "callee": "move", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L566", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "callee": "move", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L566", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "callee": "move", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L567", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_releasepollingmodewithtag", "callee": "PollingModeRelease", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L571", "receiver": "UrmaEndpoint", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_registermemoryforurma", "callee": "BAIDU_UNLIKELY", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L579", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_registermemoryforurma", "callee": "urma_register_seg", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L595", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_registermemoryforurma", "callee": "PLOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L597", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_registermemoryforurma", "callee": "BAIDU_SCOPED_LOCK", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L600", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_registermemoryforurma", "callee": "insert", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L605", "receiver": "g_user_segs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_registermemoryforurma", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L606", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_registermemoryforurma", "callee": "urma_unregister_seg", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L607", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_deregistermemoryforurma", "callee": "BAIDU_UNLIKELY", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L614", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_deregistermemoryforurma", "callee": "BAIDU_SCOPED_LOCK", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L615", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_deregistermemoryforurma", "callee": "seek", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L616", "receiver": "g_user_segs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_deregistermemoryforurma", "callee": "urma_unregister_seg", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L618", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_deregistermemoryforurma", "callee": "erase", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L619", "receiver": "g_user_segs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_getseghandle", "callee": "BAIDU_SCOPED_LOCK", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L633", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_getseghandle", "callee": "begin", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L635", "receiver": "g_user_segs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_getseghandle", "callee": "end", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L635", "receiver": "g_user_segs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L661", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "callee": "exit", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L662", "receiver": null, "lang": "cpp"}], "cpp_type_table": {"path": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp", "table": {"us": "UserSeg"}}}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/608feeb18131c6633a1d3bae5ce1bdaf944a337cafc10e12152fa2915751f7d0.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/608feeb18131c6633a1d3bae5ce1bdaf944a337cafc10e12152fa2915751f7d0.json
new file mode 100644
index 0000000000..5dc5ce90e5
--- /dev/null
+++ b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/608feeb18131c6633a1d3bae5ce1bdaf944a337cafc10e12152fa2915751f7d0.json
@@ -0,0 +1 @@
+{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "label": "mock_urma.cpp", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L1"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate", "label": "JfcState", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L54", "_callable": true}, {"id": "mutex", "label": "mutex", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate_mutex", "label": "mutex", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L55"}, {"id": "deque", "label": "deque", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "urma_cr_t", "label": "urma_cr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate_completions", "label": "completions", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L56"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate_event_pending", "label": "event_pending", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L57"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv", "label": "PendingRecv", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L60", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv_addr", "label": "addr", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L61"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv_len", "label": "len", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L62"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L63"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pushcompletion", "label": "PushCompletion()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L83", "_callable": true}, {"id": "urma_jfc_t", "label": "urma_jfc_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_init", "label": "urma_init()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L122", "_callable": true}, {"id": "urma_status_t", "label": "urma_status_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "urma_init_attr_t", "label": "urma_init_attr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "label": "urma_uninit()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L131", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "label": "urma_get_device_list()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L155", "_callable": true}, {"id": "urma_device_t", "label": "urma_device_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "label": "urma_get_device_by_name()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L195", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_free_device_list", "label": "urma_free_device_list()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L233", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_query_device", "label": "urma_query_device()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L239", "_callable": true}, {"id": "urma_device_attr_t", "label": "urma_device_attr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_eid_list", "label": "urma_get_eid_list()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L252", "_callable": true}, {"id": "urma_eid_info_t", "label": "urma_eid_info_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_free_eid_list", "label": "urma_free_eid_list()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L262", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_context", "label": "urma_create_context()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L268", "_callable": true}, {"id": "urma_context_t", "label": "urma_context_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_context", "label": "urma_delete_context()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L280", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfce", "label": "urma_create_jfce()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L290", "_callable": true}, {"id": "urma_jfce_t", "label": "urma_jfce_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfce", "label": "urma_delete_jfce()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L308", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfc", "label": "urma_create_jfc()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L319", "_callable": true}, {"id": "urma_jfc_cfg_t", "label": "urma_jfc_cfg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfc", "label": "urma_delete_jfc()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L337", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfr", "label": "urma_create_jfr()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L348", "_callable": true}, {"id": "urma_jfr_t", "label": "urma_jfr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "urma_jfr_cfg_t", "label": "urma_jfr_cfg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfr", "label": "urma_delete_jfr()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L364", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_register_seg", "label": "urma_register_seg()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L376", "_callable": true}, {"id": "urma_target_seg_t", "label": "urma_target_seg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "urma_seg_cfg_t", "label": "urma_seg_cfg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unregister_seg", "label": "urma_unregister_seg()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L392", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_seg", "label": "urma_import_seg()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L402", "_callable": true}, {"id": "urma_seg_t", "label": "urma_seg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "urma_token_t", "label": "urma_token_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "urma_import_seg_flag_t", "label": "urma_import_seg_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_seg", "label": "urma_unimport_seg()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L417", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_async_event", "label": "urma_get_async_event()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L427", "_callable": true}, {"id": "urma_async_event_t", "label": "urma_async_event_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_ack_async_event", "label": "urma_ack_async_event()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L439", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jetty", "label": "urma_create_jetty()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L441", "_callable": true}, {"id": "urma_jetty_t", "label": "urma_jetty_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "urma_jetty_cfg_t", "label": "urma_jetty_cfg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jetty", "label": "urma_delete_jetty()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L458", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unbind_jetty", "label": "urma_unbind_jetty()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L469", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_jetty", "label": "urma_import_jetty()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L478", "_callable": true}, {"id": "urma_target_jetty_t", "label": "urma_target_jetty_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "urma_rjetty_t", "label": "urma_rjetty_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_jetty", "label": "urma_unimport_jetty()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L493", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_bind_jetty", "label": "urma_bind_jetty()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L503", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_modify_jetty", "label": "urma_modify_jetty()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L514", "_callable": true}, {"id": "urma_jetty_attr_t", "label": "urma_jetty_attr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "label": "urma_post_jetty_send_wr()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L522", "_callable": true}, {"id": "urma_jfs_wr_t", "label": "urma_jfs_wr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jfr_wr", "label": "urma_post_jfr_wr()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L605", "_callable": true}, {"id": "urma_jfr_wr_t", "label": "urma_jfr_wr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "label": "urma_poll_jfc()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L627", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_rearm_jfc", "label": "urma_rearm_jfc()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L647", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_wait_jfc", "label": "urma_wait_jfc()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L651", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_ack_jfc", "label": "urma_ack_jfc()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L674", "_callable": true}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "urma_api", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L38", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "algorithm", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L40", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "atomic", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L41", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "cerrno", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L42", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "cstring", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L43", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "deque", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L44", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "map", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L45", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "mutex", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L46", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "shared_mutex", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L47", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "eventfd", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L48", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "unistd", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L49", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "vector", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L50", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L54", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate", "target": "mutex", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L55", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate_mutex", "relation": "defines", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L55", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate", "target": "deque", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L56", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate", "target": "urma_cr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L56", "weight": 1.0, "context": "generic_arg"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate_completions", "relation": "defines", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L56", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate_event_pending", "relation": "defines", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L57", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L60", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L61", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L62", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L63", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pushcompletion", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L83", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pushcompletion", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L83", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pushcompletion", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L83", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pushcompletion", "target": "urma_cr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L83", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_init", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L122", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_init", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L122", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_init", "target": "urma_init_attr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L122", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L131", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L131", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L155", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "target": "urma_device_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L155", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L195", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "target": "urma_device_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L195", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_free_device_list", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L233", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_free_device_list", "target": "urma_device_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L233", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_query_device", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L239", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_query_device", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L239", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_query_device", "target": "urma_device_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L239", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_query_device", "target": "urma_device_attr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L239", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_eid_list", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L252", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_eid_list", "target": "urma_eid_info_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L252", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_eid_list", "target": "urma_device_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L252", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_free_eid_list", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L262", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_free_eid_list", "target": "urma_eid_info_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L262", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_context", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L268", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_context", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L268", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_context", "target": "urma_device_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L268", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_context", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L280", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_context", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L280", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_context", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L280", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfce", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L290", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfce", "target": "urma_jfce_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L290", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfce", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L290", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfce", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L308", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfce", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L308", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfce", "target": "urma_jfce_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L308", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfc", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L319", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfc", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L319", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfc", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L319", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfc", "target": "urma_jfc_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L319", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfc", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L337", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfc", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L337", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfc", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L337", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L348", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfr", "target": "urma_jfr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L348", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfr", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L348", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfr", "target": "urma_jfr_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L348", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L364", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfr", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L364", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfr", "target": "urma_jfr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L364", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_register_seg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L376", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_register_seg", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L376", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_register_seg", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L376", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_register_seg", "target": "urma_seg_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L376", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unregister_seg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L392", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unregister_seg", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L392", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unregister_seg", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L392", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_seg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L402", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_seg", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L402", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_seg", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L402", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_seg", "target": "urma_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L402", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_seg", "target": "urma_token_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L402", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_seg", "target": "urma_import_seg_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L402", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_seg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L417", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_seg", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L417", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_seg", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L417", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_async_event", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L427", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_async_event", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L427", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_async_event", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L427", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_async_event", "target": "urma_async_event_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L427", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_ack_async_event", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L439", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_ack_async_event", "target": "urma_async_event_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L439", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L441", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jetty", "target": "urma_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L441", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jetty", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L441", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jetty", "target": "urma_jetty_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L441", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L458", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jetty", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L458", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jetty", "target": "urma_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L458", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unbind_jetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L469", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unbind_jetty", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L469", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unbind_jetty", "target": "urma_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L469", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_jetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L478", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_jetty", "target": "urma_target_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L478", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_jetty", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L478", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_jetty", "target": "urma_rjetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L478", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_jetty", "target": "urma_token_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L478", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_jetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L493", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_jetty", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L493", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_jetty", "target": "urma_target_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L493", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_bind_jetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L503", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_bind_jetty", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L503", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_bind_jetty", "target": "urma_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L503", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_bind_jetty", "target": "urma_target_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L503", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_modify_jetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L514", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_modify_jetty", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L514", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_modify_jetty", "target": "urma_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L514", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_modify_jetty", "target": "urma_jetty_attr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L514", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L522", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L522", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "target": "urma_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L522", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "target": "urma_jfs_wr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L522", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "target": "urma_jfs_wr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L522", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jfr_wr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L605", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jfr_wr", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L605", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jfr_wr", "target": "urma_jfr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L605", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jfr_wr", "target": "urma_jfr_wr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L605", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jfr_wr", "target": "urma_jfr_wr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L605", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L627", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L627", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "target": "urma_cr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L627", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_rearm_jfc", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L647", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_rearm_jfc", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L647", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_rearm_jfc", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L647", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_wait_jfc", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L651", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_wait_jfc", "target": "urma_jfce_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L651", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_wait_jfc", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L651", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_ack_jfc", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L674", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_ack_jfc", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L674", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pushcompletion", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L543", "weight": 1.0}], "raw_calls": [{"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pushcompletion", "callee": "push_back", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L88", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pushcompletion", "callee": "write", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L97", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L137", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L138", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L139", "receiver": "jfce_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L143", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L144", "receiver": "jfr_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L145", "receiver": "jfr_jfc_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L146", "receiver": "jfr_recv_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L147", "receiver": "seg_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L148", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L149", "receiver": "jetty_id_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L150", "receiver": "target_jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "store", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L151", "receiver": "next_jetty_id", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "empty", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L162", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "size", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L163", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "size", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L164", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "size", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L165", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "empty", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L177", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "strcpy", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L179", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "strcpy", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L180", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "push_back", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L184", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "size", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L186", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "size", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L187", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "size", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L188", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "callee": "empty", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L201", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "callee": "strcmp", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L203", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "callee": "empty", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L215", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "callee": "strcpy", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L217", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "callee": "strcpy", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L218", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "callee": "push_back", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L222", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "callee": "strcmp", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L225", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "callee": "empty", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L229", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_query_device", "callee": "memcpy", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L248", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_eid_list", "callee": "memcpy", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L258", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_context", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L282", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_context", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L282", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_context", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L285", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfce", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L292", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfce", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L292", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfce", "callee": "eventfd", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L299", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfce", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L310", "receiver": "jfce_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfce", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L310", "receiver": "jfce_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfce", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L313", "receiver": "jfce_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfce", "callee": "close", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L314", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfc", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L321", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfc", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L321", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfc", "callee": "memset", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L325", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfc", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L339", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfc", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L339", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfc", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L343", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfr", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L350", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L350", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfr", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L366", "receiver": "jfr_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L366", "receiver": "jfr_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfr", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L369", "receiver": "jfr_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfr", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L370", "receiver": "jfr_jfc_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfr", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L371", "receiver": "jfr_recv_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_register_seg", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L378", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_register_seg", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L378", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_register_seg", "callee": "memset", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L382", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unregister_seg", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L394", "receiver": "seg_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unregister_seg", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L394", "receiver": "seg_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unregister_seg", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L397", "receiver": "seg_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_seg", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L407", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_seg", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L407", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_seg", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L419", "receiver": "seg_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_seg", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L419", "receiver": "seg_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_seg", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L422", "receiver": "seg_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_async_event", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L433", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_async_event", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L433", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jetty", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L443", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jetty", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L443", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jetty", "callee": "memset", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L447", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jetty", "callee": "fetch_add", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L450", "receiver": "next_jetty_id", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jetty", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L460", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jetty", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L460", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jetty", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L463", "receiver": "jetty_id_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jetty", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L464", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unbind_jetty", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L471", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unbind_jetty", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L471", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_jetty", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L483", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_jetty", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L483", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_jetty", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L495", "receiver": "target_jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_jetty", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L495", "receiver": "target_jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_jetty", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L498", "receiver": "target_jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_bind_jetty", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L506", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_bind_jetty", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L506", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_bind_jetty", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L507", "receiver": "target_jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_bind_jetty", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L507", "receiver": "target_jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_modify_jetty", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L516", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_modify_jetty", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L516", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L525", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L527", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L528", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L529", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L530", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "unlock", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L535", "receiver": "read_lock", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L552", "receiver": "jetty_id_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L553", "receiver": "jetty_id_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L558", "receiver": "jfr_recv_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L559", "receiver": "jfr_jfc_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L560", "receiver": "jfr_recv_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "empty", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L560", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L561", "receiver": "jfr_jfc_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "front", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L564", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "pop_front", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L565", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "memcpy", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L574", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L582", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L583", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jfr_wr", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L608", "receiver": "jfr_recv_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jfr_wr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L609", "receiver": "jfr_recv_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jfr_wr", "callee": "push_back", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L618", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L631", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L632", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "callee": "empty", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L637", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "callee": "front", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L638", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "callee": "pop_front", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L639", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "callee": "empty", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L641", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_wait_jfc", "callee": "read", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L658", "receiver": null, "lang": "cpp"}], "cpp_type_table": {"path": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp", "table": {"remote_state": "JfcState", "recv": "PendingRecv", "local_state": "JfcState", "state": "JfcState"}}}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/6870b34881c2bda6a7406307467705c41b2381b7a5af286fab00d3241d6a5eca.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/6870b34881c2bda6a7406307467705c41b2381b7a5af286fab00d3241d6a5eca.json
new file mode 100644
index 0000000000..9ccaeb8d17
--- /dev/null
+++ b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/6870b34881c2bda6a7406307467705c41b2381b7a5af286fab00d3241d6a5eca.json
@@ -0,0 +1 @@
+{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "label": "urma_types.h", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_init_attr", "label": "urma_init_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L85", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_init_attr_token", "label": "token", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L86"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_init_attr_uasid", "label": "uasid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L87"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ref", "label": "urma_ref", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L152", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "label": "urma_port_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L160", "_callable": true}, {"id": "urma_mtu_t", "label": "urma_mtu_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_max_mtu", "label": "max_mtu", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L161"}, {"id": "urma_port_state_t", "label": "urma_port_state_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_state", "label": "state", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L162"}, {"id": "urma_link_width_t", "label": "urma_link_width_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_active_width", "label": "active_width", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L163"}, {"id": "urma_speed_t", "label": "urma_speed_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_active_speed", "label": "active_speed", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L164"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_active_mtu", "label": "active_mtu", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L165"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sl_info", "label": "urma_sl_info", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L178", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sl_info_sl", "label": "SL", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L179"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sl_info_tp_type", "label": "tp_type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L180"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "label": "urma_device_cap", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L254", "_callable": true}, {"id": "urma_device_feature_t", "label": "urma_device_feature_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_feature", "label": "feature", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L255"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfc", "label": "max_jfc", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L256"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs", "label": "max_jfs", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L257"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfr", "label": "max_jfr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L258"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jetty", "label": "max_jetty", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L259"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jetty_grp", "label": "max_jetty_grp", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L260"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jetty_in_jetty_grp", "label": "max_jetty_in_jetty_grp", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L261"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfc_depth", "label": "max_jfc_depth", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L262"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs_depth", "label": "max_jfs_depth", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L263"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfr_depth", "label": "max_jfr_depth", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L264"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs_inline_len", "label": "max_jfs_inline_len", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L265"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs_sge", "label": "max_jfs_sge", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L266"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs_rsge", "label": "max_jfs_rsge", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L267"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfr_sge", "label": "max_jfr_sge", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L268"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_msg_size", "label": "max_msg_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L269"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_read_size", "label": "max_read_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L270"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_write_size", "label": "max_write_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L271"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_cas_size", "label": "max_cas_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L272"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_swap_size", "label": "max_swap_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L273"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_add_size", "label": "max_fetch_and_add_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L274"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_sub_size", "label": "max_fetch_and_sub_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L275"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_and_size", "label": "max_fetch_and_and_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L276"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_or_size", "label": "max_fetch_and_or_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L277"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_xor_size", "label": "max_fetch_and_xor_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L278"}, {"id": "urma_atomic_feature_t", "label": "urma_atomic_feature_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_atomic_feat", "label": "atomic_feat", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L279"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_trans_mode", "label": "trans_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L280"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_congestion_ctrl_alg", "label": "congestion_ctrl_alg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L281"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_ceq_cnt", "label": "ceq_cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L282"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_tp_in_tpg", "label": "max_tp_in_tpg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L283"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_eid_cnt", "label": "max_eid_cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L284"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_page_size_cap", "label": "page_size_cap", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L285"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_oor_cnt", "label": "max_oor_cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L286"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_mn", "label": "mn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L287"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_netaddr_cnt", "label": "max_netaddr_cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L288"}, {"id": "urma_order_type_cap_t", "label": "urma_order_type_cap_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_rm_order_cap", "label": "rm_order_cap", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L289"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_rc_order_cap", "label": "rc_order_cap", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L290"}, {"id": "urma_tp_type_cap_t", "label": "urma_tp_type_cap_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_rm_tp_cap", "label": "rm_tp_cap", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L291"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_rc_tp_cap", "label": "rc_tp_cap", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L292"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_um_tp_cap", "label": "um_tp_cap", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L293"}, {"id": "urma_tp_feature_t", "label": "urma_tp_feature_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_tp_feature", "label": "tp_feature", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L294"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_priority_info", "label": "priority_info", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L295"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_guid", "label": "urma_guid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L298", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_guid_raw", "label": "raw", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L299"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "label": "urma_device_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L302", "_callable": true}, {"id": "urma_guid_t", "label": "urma_guid_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_guid", "label": "guid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L303"}, {"id": "urma_device_cap_t", "label": "urma_device_cap_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_dev_cap", "label": "dev_cap", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L304"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_port_cnt", "label": "port_cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L305"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_port_attr", "label": "port_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L306"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_reserved_jetty_id_min", "label": "reserved_jetty_id_min", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L307"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_reserved_jetty_id_max", "label": "reserved_jetty_id_max", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L308"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token", "label": "urma_token", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L312", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_token", "label": "token", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L313"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sysfs_dev", "label": "urma_sysfs_dev", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L316", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ops", "label": "urma_ops", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L318", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_provider_ops", "label": "urma_provider_ops", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L319", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry", "label": "urma_cc_entry", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L358", "_callable": true}, {"id": "urma_tp_cc_alg_t", "label": "urma_tp_cc_alg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry_alg", "label": "alg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L359"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry_cc_pattern_idx", "label": "cc_pattern_idx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L360"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry_cc_priority", "label": "cc_priority", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L361"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device", "label": "urma_device", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L364", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_name", "label": "name", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L365"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_path", "label": "path", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L367"}, {"id": "urma_transport_type_t", "label": "urma_transport_type_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_type", "label": "type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L368"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_ops", "label": "ops", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L369"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_sysfs_dev", "label": "sysfs_dev", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L370"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "label": "urma_context", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L383", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_dev", "label": "dev", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L384"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_ops", "label": "ops", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L385"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_dev_fd", "label": "dev_fd", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L386"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_async_fd", "label": "async_fd", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L387"}, {"id": "pthread_mutex_t", "label": "pthread_mutex_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_mutex", "label": "mutex", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L388"}, {"id": "urma_eid_t", "label": "urma_eid_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_eid", "label": "eid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L389"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_eid_index", "label": "eid_index", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L390"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_uasid", "label": "uasid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L391"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_ref", "label": "ref", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L392"}, {"id": "urma_context_aggr_mode_t", "label": "urma_context_aggr_mode_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_aggr_mode", "label": "aggr_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L393"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_eid_info", "label": "urma_eid_info", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L396", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_eid_info_eid", "label": "eid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L397"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_eid_info_eid_index", "label": "eid_index", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L398"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_cfg", "label": "urma_jfce_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L401", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_cfg_depth", "label": "depth", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L402"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_cfg_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L403"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce", "label": "urma_jfce", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L406", "_callable": true}, {"id": "urma_context_t", "label": "urma_context_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L407"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_fd", "label": "fd", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L408"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_ref", "label": "ref", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L409"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg", "label": "urma_jfc_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L423", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_depth", "label": "depth", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L424"}, {"id": "urma_jfc_flag_t", "label": "urma_jfc_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L425"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_ceqn", "label": "ceqn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L426"}, {"id": "urma_jfce_t", "label": "urma_jfce_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_jfce", "label": "jfce", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L428"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L429"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr", "label": "urma_jfc_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L437", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr_mask", "label": "mask", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L438"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr_moderate_count", "label": "moderate_count", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L439"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr_moderate_period", "label": "moderate_period", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L440"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id", "label": "urma_jetty_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L443", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id_eid", "label": "eid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L444"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id_uasid", "label": "uasid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L445"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id_id", "label": "id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L446"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "label": "urma_jfc_opt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L467", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_jfc_opt_mask", "label": "jfc_opt_mask", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L468"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_is_actived", "label": "is_actived", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L470"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_cqe_base_addr", "label": "urma_jfc_cqe_base_addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L471"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_id", "label": "urma_jfc_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L472"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_db_addr", "label": "urma_jfc_db_addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L473"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_db_status", "label": "urma_jfc_db_status", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L474"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_pi", "label": "urma_jfc_pi", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L475"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_pi_type", "label": "urma_jfc_pi_type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L476"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_ci", "label": "urma_jfc_ci", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L477"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_reserved", "label": "reserved", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L478"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "label": "urma_jfc", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L481", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L482"}, {"id": "urma_jfc_id_t", "label": "urma_jfc_id_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_jfc_id", "label": "jfc_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L483"}, {"id": "urma_jfc_cfg_t", "label": "urma_jfc_cfg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_jfc_cfg", "label": "jfc_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L484"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_handle", "label": "handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L485"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_event_mutex", "label": "event_mutex", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L486"}, {"id": "pthread_cond_t", "label": "pthread_cond_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_event_cond", "label": "event_cond", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L487"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_comp_events_acked", "label": "comp_events_acked", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L488"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_async_events_acked", "label": "async_events_acked", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L489"}, {"id": "urma_jfc_opt_t", "label": "urma_jfc_opt_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_urma_jfc_opt", "label": "urma_jfc_opt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L490"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "label": "urma_jfs_opt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L534", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_jfs_opt_mask", "label": "jfs_opt_mask", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L535"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_is_actived", "label": "is_actived", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L537"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_sqe_base_addr", "label": "urma_jfs_sqe_base_addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L538"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_id", "label": "urma_jfs_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L539"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_db_addr", "label": "urma_jfs_db_addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L540"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_db_status", "label": "urma_jfs_db_status", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L541"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_pi", "label": "urma_jfs_pi", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L542"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_pi_type", "label": "urma_jfs_pi_type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L543"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_ci", "label": "urma_jfs_ci", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L544"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_reserved", "label": "reserved", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L545"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "label": "urma_jfs_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L548", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_depth", "label": "depth", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L549"}, {"id": "urma_jfs_flag_t", "label": "urma_jfs_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L550"}, {"id": "urma_transport_mode_t", "label": "urma_transport_mode_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_trans_mode", "label": "trans_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L551"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_priority", "label": "priority", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L552"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_max_sge", "label": "max_sge", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L554"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_max_rsge", "label": "max_rsge", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L555"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_max_inline_data", "label": "max_inline_data", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L556"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_rnr_retry", "label": "rnr_retry", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L558"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_err_timeout", "label": "err_timeout", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L562"}, {"id": "urma_jfc_t", "label": "urma_jfc_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_jfc", "label": "jfc", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L564"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L565"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "label": "urma_jfs", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L568", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L569"}, {"id": "urma_jfs_id_t", "label": "urma_jfs_id_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_jfs_id", "label": "jfs_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L570"}, {"id": "urma_jfs_cfg_t", "label": "urma_jfs_cfg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_jfs_cfg", "label": "jfs_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L571"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_handle", "label": "handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L572"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_event_mutex", "label": "event_mutex", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L573"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_event_cond", "label": "event_cond", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L574"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_async_events_acked", "label": "async_events_acked", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L575"}, {"id": "urma_jfs_opt_t", "label": "urma_jfs_opt_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_urma_jfs_opt", "label": "urma_jfs_opt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L576"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_attr", "label": "urma_jfs_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L585", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_attr_mask", "label": "mask", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L586"}, {"id": "urma_jfs_state_t", "label": "urma_jfs_state_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_attr_state", "label": "state", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L587"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "label": "urma_jfr_opt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L625", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_jfr_opt_mask", "label": "jfr_opt_mask", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L626"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_is_actived", "label": "is_actived", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L628"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_rqe_base_addr", "label": "urma_jfr_rqe_base_addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L629"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_id", "label": "urma_jfr_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L630"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_db_addr", "label": "urma_jfr_db_addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L631"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_db_status", "label": "urma_jfr_db_status", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L632"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_pi", "label": "urma_jfr_pi", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L633"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_pi_type", "label": "urma_jfr_pi_type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L634"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_ci", "label": "urma_jfr_ci", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L635"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_reserved", "label": "reserved", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L636"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "label": "urma_jfr_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L639", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_id", "label": "id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L640"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_depth", "label": "depth", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L642"}, {"id": "urma_jfr_flag_t", "label": "urma_jfr_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L643"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_trans_mode", "label": "trans_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L644"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_max_sge", "label": "max_sge", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L645"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_min_rnr_timer", "label": "min_rnr_timer", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L646"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_jfc", "label": "jfc", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L648"}, {"id": "urma_token_t", "label": "urma_token_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_token_value", "label": "token_value", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L649"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L650"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr", "label": "urma_jfr_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L658", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr_mask", "label": "mask", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L659"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr_rx_threshold", "label": "rx_threshold", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L660"}, {"id": "urma_jfr_state_t", "label": "urma_jfr_state_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr_state", "label": "state", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L661"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "label": "urma_jfr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L664", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L665"}, {"id": "urma_jfr_id_t", "label": "urma_jfr_id_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_jfr_id", "label": "jfr_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L666"}, {"id": "urma_jfr_cfg_t", "label": "urma_jfr_cfg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_jfr_cfg", "label": "jfr_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L667"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_handle", "label": "handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L668"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_event_mutex", "label": "event_mutex", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L669"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_event_cond", "label": "event_cond", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L670"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_async_events_acked", "label": "async_events_acked", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L671"}, {"id": "urma_jfr_opt_t", "label": "urma_jfr_opt_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_urma_jfr_opt", "label": "urma_jfr_opt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L672"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "label": "urma_rjfr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L702", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr_jfr_id", "label": "jfr_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L703"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr_trans_mode", "label": "trans_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L704"}, {"id": "urma_import_jetty_flag_t", "label": "urma_import_jetty_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L705"}, {"id": "urma_tp_type_t", "label": "urma_tp_type_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr_tp_type", "label": "tp_type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L706"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp", "label": "urma_tp", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L709", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_tpn", "label": "tpn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L710"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "label": "urma_jetty_grp", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L724", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "label": "urma_jetty_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L726", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_id", "label": "id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L727"}, {"id": "urma_jetty_flag_t", "label": "urma_jetty_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L728"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_jfs_cfg", "label": "jfs_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L731"}, {"id": "urma_jetty_grp_t", "label": "urma_jetty_grp_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_jetty_grp", "label": "jetty_grp", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L741"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L742"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "label": "urma_rjetty", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L756", "_callable": true}, {"id": "urma_jetty_id_t", "label": "urma_jetty_id_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_jetty_id", "label": "jetty_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L757"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_trans_mode", "label": "trans_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L758"}, {"id": "urma_jetty_grp_policy_t", "label": "urma_jetty_grp_policy_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_policy", "label": "policy", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L759"}, {"id": "urma_target_type_t", "label": "urma_target_type_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_type", "label": "type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L760"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L761"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_tp_type", "label": "tp_type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L762"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "label": "urma_target_jetty", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L765", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L766"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_id", "label": "id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L767"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_handle", "label": "handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L768"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_trans_mode", "label": "trans_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L769"}, {"id": "urma_tp_t", "label": "urma_tp_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_tp", "label": "tp", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L770"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_type", "label": "type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L771"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L772"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_policy", "label": "policy", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L773"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_tp_type", "label": "tp_type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L774"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr", "label": "urma_jetty_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L782", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr_mask", "label": "mask", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L783"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr_rx_threshold", "label": "rx_threshold", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L784"}, {"id": "urma_jetty_state_t", "label": "urma_jetty_state_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr_state", "label": "state", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L785"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt", "label": "urma_jetty_opt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L788", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt_is_actived", "label": "is_actived", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L789"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt_jfs_opt", "label": "jfs_opt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L790"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt_reserved", "label": "reserved", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L791"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "label": "urma_jetty", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L794", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L795"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_jetty_id", "label": "jetty_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L796"}, {"id": "urma_target_jetty_t", "label": "urma_target_jetty_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_remote_jetty", "label": "remote_jetty", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L797"}, {"id": "urma_jetty_cfg_t", "label": "urma_jetty_cfg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_jetty_cfg", "label": "jetty_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L799"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_handle", "label": "handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L800"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_event_mutex", "label": "event_mutex", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L801"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_event_cond", "label": "event_cond", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L802"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_async_events_acked", "label": "async_events_acked", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L803"}, {"id": "urma_jetty_opt_t", "label": "urma_jetty_opt_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_urma_jetty_opt", "label": "urma_jetty_opt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L804"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier", "label": "urma_notifier", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L807", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L808"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier_fd", "label": "fd", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L809"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier_incomplete_tjetty_list", "label": "incomplete_tjetty_list", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L810"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify", "label": "urma_notify", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L818", "_callable": true}, {"id": "urma_notify_type_t", "label": "urma_notify_type_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify_type", "label": "type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L819"}, {"id": "urma_status_t", "label": "urma_status_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify_status", "label": "status", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L820"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L821"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "label": "urma_jetty_grp_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L840", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_name", "label": "name", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L841"}, {"id": "urma_jetty_grp_flag_t", "label": "urma_jetty_grp_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L842"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_token_value", "label": "token_value", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L843"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_id", "label": "id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L844"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_policy", "label": "policy", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L846"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L847"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L851"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_jetty_grp_id", "label": "jetty_grp_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L852"}, {"id": "urma_jetty_grp_cfg_t", "label": "urma_jetty_grp_cfg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_jetty_cnt", "label": "jetty_cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L854"}, {"id": "urma_jetty_t", "label": "urma_jetty_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_jetty_list", "label": "jetty_list", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L855"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_list_mutex", "label": "list_mutex", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L856"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_handle", "label": "handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L857"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_event_mutex", "label": "event_mutex", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L858"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_event_cond", "label": "event_cond", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L859"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_async_events_acked", "label": "async_events_acked", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L860"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva", "label": "urma_ubva", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L864", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva_eid", "label": "eid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L865"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva_uasid", "label": "uasid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L866"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva_va", "label": "va", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L867"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "label": "urma_token_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L946", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L947"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_token_id", "label": "token_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L948"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_handle", "label": "handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L949"}, {"id": "urma_ref_t", "label": "urma_ref_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_ref", "label": "ref", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L950"}, {"id": "urma_token_id_flag_t", "label": "urma_token_id_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L951"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "label": "urma_seg_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L954", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_va", "label": "va", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L955"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_len", "label": "len", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L956"}, {"id": "urma_token_id_t", "label": "urma_token_id_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_token_id", "label": "token_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L957"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_token_value", "label": "token_value", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L958"}, {"id": "urma_reg_seg_flag_t", "label": "urma_reg_seg_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L959"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L960"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_iova", "label": "iova", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L961"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg", "label": "urma_seg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L964", "_callable": true}, {"id": "urma_ubva_t", "label": "urma_ubva_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_ubva", "label": "ubva", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L965"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_len", "label": "len", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L966"}, {"id": "urma_seg_attr_t", "label": "urma_seg_attr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_attr", "label": "attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L967"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_token_id", "label": "token_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L968"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "label": "urma_target_seg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L971", "_callable": true}, {"id": "urma_seg_t", "label": "urma_seg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_seg", "label": "seg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L972"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L973"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_mva", "label": "mva", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L974"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L975"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_token_id", "label": "token_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L976"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_handle", "label": "handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L977"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in", "label": "urma_user_ctl_in", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L980", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in_addr", "label": "addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L981"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in_len", "label": "len", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L982"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in_opcode", "label": "opcode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L987"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out", "label": "urma_user_ctl_out", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L990", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out_addr", "label": "addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L991"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out_len", "label": "len", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L992"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out_reserved", "label": "reserved", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L993"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg", "label": "urma_user_target_seg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L996", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg_attr", "label": "attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L997"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg_token_id", "label": "token_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L998"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg_token_value", "label": "token_value", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L999"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge", "label": "urma_sge", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1002", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge_addr", "label": "addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1003"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge_len", "label": "len", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1004"}, {"id": "urma_target_seg_t", "label": "urma_target_seg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge_tseg", "label": "tseg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1010"}, {"id": "urma_user_tseg_t", "label": "urma_user_tseg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge_user_tseg", "label": "user_tseg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1011"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sg", "label": "urma_sg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1014", "_callable": true}, {"id": "urma_sge_t", "label": "urma_sge_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sg_sge", "label": "sge", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1015"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sg_num_sge", "label": "num_sge", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1016"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr", "label": "urma_rw_wr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1053", "_callable": true}, {"id": "urma_sg_t", "label": "urma_sg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr_src", "label": "src", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1054"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr_dst", "label": "dst", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1056"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr_target_hint", "label": "target_hint", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1058"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr_notify_data", "label": "notify_data", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1059"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr", "label": "urma_send_wr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1062", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr_src", "label": "src", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1063"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr_target_hint", "label": "target_hint", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1064"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr_imm_data", "label": "imm_data", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1065"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr_tseg", "label": "tseg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1066"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr", "label": "urma_cas_wr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1069", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr_dst", "label": "dst", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1070"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr_src", "label": "src", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1071"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr", "label": "urma_faa_wr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1082", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr_dst", "label": "dst", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1083"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr_src", "label": "src", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1084"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "label": "urma_jfs_wr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1091", "_callable": true}, {"id": "urma_opcode_t", "label": "urma_opcode_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_opcode", "label": "opcode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1092"}, {"id": "urma_jfs_wr_flag_t", "label": "urma_jfs_wr_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1093"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_tjetty", "label": "tjetty", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1094"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1095"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_next", "label": "next", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1102"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr", "label": "urma_jfr_wr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1105", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr_src", "label": "src", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1106"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1107"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr_next", "label": "next", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1108"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_token", "label": "urma_cr_token", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1122", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_token_token_id", "label": "token_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1123"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_token_token_value", "label": "token_value", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1124"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "label": "urma_cr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1127", "_callable": true}, {"id": "urma_cr_status_t", "label": "urma_cr_status_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_status", "label": "status", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1128"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1129"}, {"id": "urma_cr_opcode_t", "label": "urma_cr_opcode_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_opcode", "label": "opcode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1130"}, {"id": "urma_cr_flag_t", "label": "urma_cr_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1131"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_completion_len", "label": "completion_len", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1132"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_local_id", "label": "local_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1134"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_remote_id", "label": "remote_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1135"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_tpn", "label": "tpn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1141"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_user_data", "label": "user_data", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1142"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event", "label": "urma_async_event", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1145", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1147"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event_element", "label": "element", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1156"}, {"id": "urma_async_event_type_t", "label": "urma_async_event_type_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event_event_type", "label": "event_type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1157"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event_priv", "label": "priv", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1158"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur", "label": "urma_ur", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1184", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_name", "label": "name", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1185"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_size", "label": "size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1186"}, {"id": "urma_ur_attr_t", "label": "urma_ur_attr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_attr", "label": "attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1187"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_token", "label": "token", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1188"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1189"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur", "label": "urma_target_ur", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1193", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_name", "label": "name", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1194"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_size", "label": "size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1195"}, {"id": "urma_import_ur_flag_t", "label": "urma_import_ur_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1196"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_tseg_list", "label": "tseg_list", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1197"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_cnt", "label": "cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1198"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_info", "label": "urma_seg_info", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1201", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_info_seg", "label": "seg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1202"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_info_idx_in_ur", "label": "idx_in_ur", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1203"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info", "label": "urma_ur_info", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1207", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_name", "label": "name", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1208"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_size", "label": "size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1209"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_attr", "label": "attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1210"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_cnt", "label": "cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1211"}, {"id": "urma_seg_info_t", "label": "urma_seg_info_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_seg_list", "label": "seg_list", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1212"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info", "label": "urma_jfr_info", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1215", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info_name", "label": "name", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1216"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info_eid", "label": "eid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1217"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info_uasid", "label": "uasid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1218"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info_id", "label": "id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1219"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "label": "urma_tp_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1238", "_callable": true}, {"id": "urma_tp_cfg_flag_t", "label": "urma_tp_cfg_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1239"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_trans_mode", "label": "trans_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1241"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_retry_num", "label": "retry_num", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1242"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_retry_factor", "label": "retry_factor", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1243"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_ack_timeout", "label": "ack_timeout", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1244"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_dscp", "label": "dscp", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1245"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_oor_cnt", "label": "oor_cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1246"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr", "label": "urma_net_addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1295", "_callable": true}, {"id": "sa_family_t", "label": "sa_family_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_sin_family", "label": "sin_family", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1296"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_vlan", "label": "vlan", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1301"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_mac", "label": "mac", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1302"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_prefix_len", "label": "prefix_len", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1303"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_info", "label": "urma_net_addr_info", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1306", "_callable": true}, {"id": "urma_net_addr_t", "label": "urma_net_addr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_info_netaddr", "label": "netaddr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1307"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_info_index", "label": "index", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1308"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "label": "urma_tp_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1311", "_callable": true}, {"id": "urma_tp_mod_flag_t", "label": "urma_tp_mod_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1312"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_peer_tpn", "label": "peer_tpn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1313"}, {"id": "urma_tp_state_t", "label": "urma_tp_state_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_state", "label": "state", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1314"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_tx_psn", "label": "tx_psn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1315"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_rx_psn", "label": "rx_psn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1316"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_mtu", "label": "mtu", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1317"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_cc_pattern_idx", "label": "cc_pattern_idx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1318"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_oos_cnt", "label": "oos_cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1319"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_local_net_addr_idx", "label": "local_net_addr_idx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1320"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_peer_net_addr", "label": "peer_net_addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1321"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_data_udp_start", "label": "data_udp_start", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1322"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_ack_udp_start", "label": "ack_udp_start", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1323"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_udp_range", "label": "udp_range", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1324"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_hop_limit", "label": "hop_limit", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1325"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_flow_label", "label": "flow_label", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1326"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_port_id", "label": "port_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1327"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_mn", "label": "mn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1328"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_peer_trans_type", "label": "peer_trans_type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1329"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "label": "urma_get_tp_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1347", "_callable": true}, {"id": "urma_get_tp_cfg_flag_t", "label": "urma_get_tp_cfg_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1348"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg_trans_mode", "label": "trans_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1349"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg_local_eid", "label": "local_eid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1350"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg_peer_eid", "label": "peer_eid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1351"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_info", "label": "urma_tp_info", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1354", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_info_tp_handle", "label": "tp_handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1355"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr", "label": "urma_active_tp_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1358", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr_tx_psn", "label": "tx_psn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1359"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr_rx_psn", "label": "rx_psn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1360"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr_reserved", "label": "reserved", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1361"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "label": "urma_active_tp_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1364", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg_tp_handle", "label": "tp_handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1365"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg_peer_tp_handle", "label": "peer_tp_handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1366"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg_tag", "label": "tag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1367"}, {"id": "urma_active_tp_attr_t", "label": "urma_active_tp_attr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg_tp_attr", "label": "tp_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1368"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "label": "urma_tp_attr_value", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1376", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_retry_times_init", "label": "retry_times_init", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1377"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_at", "label": "at", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1378"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_sip", "label": "sip", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1379"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_dip", "label": "dip", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1380"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_sma", "label": "sma", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1381"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_dma", "label": "dma", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1382"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_vlan_id", "label": "vlan_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1383"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_vlan_en", "label": "vlan_en", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1384"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_dscp", "label": "dscp", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1385"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_at_times", "label": "at_times", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1386"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_sl", "label": "sl", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1387"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_ttl", "label": "ttl", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1388"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_ack_udp_srcport", "label": "ack_udp_srcport", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1389"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_data_udp_srcport", "label": "data_udp_srcport", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1390"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_udp_srcport_range", "label": "udp_srcport_range", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1391"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_spray_en", "label": "spray_en", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1392"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_udp_global_en", "label": "udp_global_en", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1393"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_reserve_0", "label": "reserve_0", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1394"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_sl_bitmap", "label": "sl_bitmap", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1395"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_dscp_config_mode", "label": "dscp_config_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1396"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_reserve_1", "label": "reserve_1", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1397"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_reserved", "label": "reserved", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1398"}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "inet", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L14", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "pthread", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L15", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "stdint", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L16", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "stdbool", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L17", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "socket", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L18", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "stdatomic", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L21", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "atomic", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L23", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "urma_opcode", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L26", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_init_attr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L85", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_init_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_init_attr_token", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L86", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_init_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_init_attr_uasid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L87", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ref", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L152", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L160", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "urma_mtu_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L161", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_max_mtu", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L161", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "urma_port_state_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L162", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_state", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L162", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "urma_link_width_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L163", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_active_width", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L163", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "urma_speed_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L164", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_active_speed", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L164", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "urma_mtu_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L165", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_active_mtu", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L165", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sl_info", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L178", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sl_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sl_info_sl", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L179", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sl_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sl_info_tp_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L180", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L254", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "urma_device_feature_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L255", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_feature", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L255", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfc", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L256", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L257", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L258", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jetty", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L259", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jetty_grp", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L260", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jetty_in_jetty_grp", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L261", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfc_depth", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L262", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs_depth", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L263", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfr_depth", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L264", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs_inline_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L265", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs_sge", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L266", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs_rsge", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L267", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfr_sge", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L268", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_msg_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L269", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_read_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L270", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_write_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L271", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_cas_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L272", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_swap_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L273", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_add_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L274", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_sub_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L275", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_and_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L276", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_or_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L277", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_xor_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L278", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "urma_atomic_feature_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L279", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_atomic_feat", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L279", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_trans_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L280", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_congestion_ctrl_alg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L281", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_ceq_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L282", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_tp_in_tpg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L283", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_eid_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L284", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_page_size_cap", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L285", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_oor_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L286", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_mn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L287", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_netaddr_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L288", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "urma_order_type_cap_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L289", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_rm_order_cap", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L289", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "urma_order_type_cap_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L290", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_rc_order_cap", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L290", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "urma_tp_type_cap_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L291", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_rm_tp_cap", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L291", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "urma_tp_type_cap_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L292", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_rc_tp_cap", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L292", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "urma_tp_type_cap_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L293", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_um_tp_cap", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L293", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "urma_tp_feature_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L294", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_tp_feature", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L294", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_priority_info", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L295", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_guid", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L298", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_guid", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_guid_raw", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L299", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L302", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "target": "urma_guid_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L303", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_guid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L303", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "target": "urma_device_cap_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L304", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_dev_cap", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L304", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_port_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L305", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_port_attr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L306", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_reserved_jetty_id_min", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L307", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_reserved_jetty_id_max", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L308", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L312", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_token", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L313", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sysfs_dev", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L316", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ref", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L317", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ops", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L318", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_provider_ops", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L319", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L358", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry", "target": "urma_tp_cc_alg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L359", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry_alg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L359", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry_cc_pattern_idx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L360", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry_cc_priority", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L361", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L364", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_name", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L365", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_path", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L367", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device", "target": "urma_transport_type_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L368", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L368", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_ops", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L369", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_sysfs_dev", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L370", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L383", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_dev", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L384", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_ops", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L385", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_dev_fd", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L386", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_async_fd", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L387", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "pthread_mutex_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L388", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_mutex", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L388", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "urma_eid_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L389", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L389", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_eid_index", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L390", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_uasid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L391", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_ref", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L392", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "urma_context_aggr_mode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L393", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_aggr_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L393", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_eid_info", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L396", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_eid_info", "target": "urma_eid_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L397", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_eid_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_eid_info_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L397", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_eid_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_eid_info_eid_index", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L398", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L401", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_cfg_depth", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L402", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_cfg_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L403", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L406", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L407", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L407", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_fd", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L408", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_ref", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L409", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L423", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_depth", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L424", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg", "target": "urma_jfc_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L425", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L425", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_ceqn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L426", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg", "target": "urma_jfce_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L428", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_jfce", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L428", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L429", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L437", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr_mask", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L438", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr_moderate_count", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L439", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr_moderate_period", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L440", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L443", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id", "target": "urma_eid_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L444", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L444", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id_uasid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L445", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L446", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L449", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L450", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L451", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L467", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_jfc_opt_mask", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L468", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_is_actived", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L470", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_cqe_base_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L471", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L472", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_db_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L473", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_db_status", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L474", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_pi", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L475", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_pi_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L476", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_ci", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L477", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_reserved", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L478", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L481", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L482", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L482", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "urma_jfc_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L483", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_jfc_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L483", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "urma_jfc_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L484", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_jfc_cfg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L484", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L485", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "pthread_mutex_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L486", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_event_mutex", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L486", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "pthread_cond_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L487", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_event_cond", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L487", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_comp_events_acked", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L488", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_async_events_acked", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L489", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "urma_jfc_opt_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L490", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_urma_jfc_opt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L490", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L534", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_jfs_opt_mask", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L535", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_is_actived", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L537", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_sqe_base_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L538", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L539", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_db_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L540", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_db_status", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L541", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_pi", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L542", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_pi_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L543", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_ci", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L544", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_reserved", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L545", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L548", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_depth", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L549", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "urma_jfs_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L550", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L550", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "urma_transport_mode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L551", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_trans_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L551", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_priority", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L552", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_max_sge", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L554", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_max_rsge", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L555", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_max_inline_data", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L556", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_rnr_retry", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L558", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_err_timeout", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L562", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L564", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_jfc", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L564", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L565", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L568", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L569", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L569", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "urma_jfs_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L570", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_jfs_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L570", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "urma_jfs_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L571", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_jfs_cfg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L571", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L572", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "pthread_mutex_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L573", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_event_mutex", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L573", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "pthread_cond_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L574", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_event_cond", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L574", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_async_events_acked", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L575", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "urma_jfs_opt_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L576", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_urma_jfs_opt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L576", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_attr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L585", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_attr_mask", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L586", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_attr", "target": "urma_jfs_state_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L587", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_attr_state", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L587", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L625", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_jfr_opt_mask", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L626", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_is_actived", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L628", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_rqe_base_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L629", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L630", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_db_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L631", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_db_status", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L632", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_pi", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L633", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_pi_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L634", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_ci", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L635", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_reserved", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L636", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L639", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L640", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_depth", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L642", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "urma_jfr_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L643", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L643", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "urma_transport_mode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L644", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_trans_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L644", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_max_sge", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L645", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_min_rnr_timer", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L646", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L648", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_jfc", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L648", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "urma_token_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L649", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_token_value", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L649", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L650", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L658", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr_mask", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L659", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr_rx_threshold", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L660", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr", "target": "urma_jfr_state_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L661", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr_state", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L661", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L664", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L665", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L665", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "urma_jfr_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L666", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_jfr_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L666", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "urma_jfr_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L667", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_jfr_cfg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L667", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L668", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "pthread_mutex_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L669", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_event_mutex", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L669", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "pthread_cond_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L670", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_event_cond", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L670", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_async_events_acked", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L671", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "urma_jfr_opt_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L672", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_urma_jfr_opt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L672", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L702", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "target": "urma_jfr_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L703", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr_jfr_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L703", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "target": "urma_transport_mode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L704", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr_trans_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L704", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "target": "urma_import_jetty_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L705", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L705", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "target": "urma_tp_type_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L706", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr_tp_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L706", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L709", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_tpn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L710", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L724", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L726", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L727", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "target": "urma_jetty_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L728", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L728", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "target": "urma_jfs_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L731", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_jfs_cfg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L731", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "target": "urma_jetty_grp_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L741", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_jetty_grp", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L741", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L742", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L756", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "urma_jetty_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L757", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_jetty_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L757", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "urma_transport_mode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L758", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_trans_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L758", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "urma_jetty_grp_policy_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L759", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_policy", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L759", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "urma_target_type_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L760", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L760", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "urma_import_jetty_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L761", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L761", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "urma_tp_type_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L762", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_tp_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L762", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L765", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L766", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L766", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "urma_jetty_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L767", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L767", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L768", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "urma_transport_mode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L769", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_trans_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L769", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "urma_tp_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L770", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_tp", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L770", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "urma_target_type_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L771", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L771", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "urma_import_jetty_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L772", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L772", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "urma_jetty_grp_policy_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L773", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_policy", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L773", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "urma_tp_type_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L774", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_tp_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L774", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L782", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr_mask", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L783", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr_rx_threshold", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L784", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr", "target": "urma_jetty_state_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L785", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr_state", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L785", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L788", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt_is_actived", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L789", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt", "target": "urma_jfs_opt_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L790", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt_jfs_opt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L790", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt_reserved", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L791", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L794", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L795", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L795", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "urma_jetty_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L796", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_jetty_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L796", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "urma_target_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L797", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_remote_jetty", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L797", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "urma_jetty_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L799", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_jetty_cfg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L799", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L800", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "pthread_mutex_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L801", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_event_mutex", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L801", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "pthread_cond_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L802", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_event_cond", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L802", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_async_events_acked", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L803", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "urma_jetty_opt_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L804", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_urma_jetty_opt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L804", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L807", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L808", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L808", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier_fd", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L809", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier_incomplete_tjetty_list", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L810", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L818", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify", "target": "urma_notify_type_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L819", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L819", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L820", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify_status", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L820", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L821", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L840", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_name", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L841", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "target": "urma_jetty_grp_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L842", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L842", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "target": "urma_token_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L843", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_token_value", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L843", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L844", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "target": "urma_jetty_grp_policy_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L846", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_policy", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L846", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L847", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L850", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L851", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L851", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "urma_jetty_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L852", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_jetty_grp_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L852", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "urma_jetty_grp_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L853", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L853", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_jetty_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L854", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "urma_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L855", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_jetty_list", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L855", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "pthread_mutex_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L856", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_list_mutex", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L856", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L857", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "pthread_mutex_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L858", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_event_mutex", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L858", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "pthread_cond_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L859", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_event_cond", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L859", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_async_events_acked", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L860", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L864", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva", "target": "urma_eid_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L865", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L865", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva_uasid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L866", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva_va", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L867", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L946", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L947", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L947", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_token_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L948", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L949", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "target": "urma_ref_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L950", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_ref", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L950", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "target": "urma_token_id_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L951", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L951", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L954", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_va", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L955", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L956", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "urma_token_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L957", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_token_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L957", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "urma_token_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L958", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_token_value", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L958", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "urma_reg_seg_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L959", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L959", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L960", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_iova", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L961", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L964", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg", "target": "urma_ubva_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L965", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_ubva", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L965", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L966", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg", "target": "urma_seg_attr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L967", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_attr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L967", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_token_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L968", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L971", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "target": "urma_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L972", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_seg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L972", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L973", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_mva", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L974", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L975", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L975", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "target": "urma_token_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L976", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_token_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L976", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L977", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L980", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L981", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L982", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in_opcode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L987", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L990", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L991", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L992", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out_reserved", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L993", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L996", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg", "target": "urma_seg_attr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L997", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg_attr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L997", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg_token_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L998", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg", "target": "urma_token_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L999", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg_token_value", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L999", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1002", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1003", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1004", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1010", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge_tseg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1010", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge", "target": "urma_user_tseg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1011", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge_user_tseg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1011", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1014", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sg", "target": "urma_sge_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1015", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sg_sge", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1015", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sg_num_sge", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1016", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1053", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr", "target": "urma_sg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1054", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr_src", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1054", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr", "target": "urma_sg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1056", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr_dst", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1056", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr_target_hint", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1058", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr_notify_data", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1059", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1062", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr", "target": "urma_sg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1063", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr_src", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1063", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr_target_hint", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1064", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr_imm_data", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1065", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1066", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr_tseg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1066", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1069", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr", "target": "urma_sge_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1070", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr_dst", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1070", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr", "target": "urma_sge_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1071", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr_src", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1071", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1082", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr", "target": "urma_sge_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1083", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr_dst", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1083", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr", "target": "urma_sge_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1084", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr_src", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1084", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1091", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "target": "urma_opcode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1092", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_opcode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1092", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "target": "urma_jfs_wr_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1093", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1093", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "target": "urma_target_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1094", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_tjetty", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1094", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1095", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_next", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1102", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1105", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr", "target": "urma_sg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1106", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr_src", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1106", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1107", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr_next", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1108", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_token", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1122", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_token", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_token_token_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1123", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_token", "target": "urma_token_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1124", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_token", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_token_token_value", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1124", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1127", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "urma_cr_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1128", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_status", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1128", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1129", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "urma_cr_opcode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1130", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_opcode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1130", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "urma_cr_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1131", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1131", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_completion_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1132", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_local_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1134", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "urma_jetty_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1135", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_remote_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1135", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_tpn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1141", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_user_data", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1142", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1145", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1147", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1147", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event_element", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1156", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event", "target": "urma_async_event_type_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1157", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event_event_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1157", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event_priv", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1158", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1184", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_name", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1185", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1186", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur", "target": "urma_ur_attr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1187", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_attr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1187", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_token", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1188", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1189", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1193", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_name", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1194", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1195", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur", "target": "urma_import_ur_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1196", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1196", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1197", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_tseg_list", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1197", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1198", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_info", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1201", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_info", "target": "urma_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1202", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_info_seg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1202", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_info_idx_in_ur", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1203", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1207", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_name", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1208", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1209", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info", "target": "urma_ur_attr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1210", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_attr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1210", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1211", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info", "target": "urma_seg_info_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1212", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_seg_list", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1212", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1215", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info_name", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1216", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info", "target": "urma_eid_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1217", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1217", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info_uasid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1218", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1219", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1238", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "target": "urma_tp_cfg_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1239", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1239", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "target": "urma_transport_mode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1241", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_trans_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1241", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_retry_num", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1242", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_retry_factor", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1243", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_ack_timeout", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1244", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_dscp", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1245", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_oor_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1246", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1295", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr", "target": "sa_family_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1296", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_sin_family", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1296", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_vlan", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1301", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_mac", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1302", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_prefix_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1303", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_info", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1306", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_info", "target": "urma_net_addr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1307", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_info_netaddr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1307", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_info_index", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1308", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1311", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "urma_tp_mod_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1312", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1312", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_peer_tpn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1313", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "urma_tp_state_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1314", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_state", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1314", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_tx_psn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1315", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_rx_psn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1316", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "urma_mtu_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1317", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_mtu", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1317", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_cc_pattern_idx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1318", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_oos_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1319", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_local_net_addr_idx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1320", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "urma_net_addr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1321", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_peer_net_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1321", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_data_udp_start", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1322", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_ack_udp_start", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1323", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_udp_range", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1324", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_hop_limit", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1325", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_flow_label", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1326", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_port_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1327", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_mn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1328", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "urma_transport_type_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1329", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_peer_trans_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1329", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1347", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "target": "urma_get_tp_cfg_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1348", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1348", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "target": "urma_transport_mode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1349", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg_trans_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1349", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "target": "urma_eid_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1350", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg_local_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1350", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "target": "urma_eid_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1351", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg_peer_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1351", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_info", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1354", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_info_tp_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1355", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1358", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr_tx_psn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1359", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr_rx_psn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1360", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr_reserved", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1361", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1364", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg_tp_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1365", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg_peer_tp_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1366", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg_tag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1367", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "target": "urma_active_tp_attr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1368", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg_tp_attr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1368", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1371", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1372", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1373", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1376", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_retry_times_init", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1377", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_at", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1378", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_sip", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1379", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_dip", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1380", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_sma", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1381", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_dma", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1382", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_vlan_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1383", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_vlan_en", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1384", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_dscp", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1385", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_at_times", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1386", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_sl", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1387", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_ttl", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1388", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_ack_udp_srcport", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1389", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_data_udp_srcport", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1390", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_udp_srcport_range", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1391", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_spray_en", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1392", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_udp_global_en", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1393", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_reserve_0", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1394", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_sl_bitmap", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1395", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_dscp_config_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1396", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_reserve_1", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1397", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_reserved", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1398", "weight": 1.0, "context": "field"}], "raw_calls": []}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/7899e48f9378edf160c448d2d8eb8cdaa14683461e3f2562a4ce8dedce8721ed.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/7899e48f9378edf160c448d2d8eb8cdaa14683461e3f2562a4ce8dedce8721ed.json
new file mode 100644
index 0000000000..0ffde6c745
--- /dev/null
+++ b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/7899e48f9378edf160c448d2d8eb8cdaa14683461e3f2562a4ce8dedce8721ed.json
@@ -0,0 +1 @@
+{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "label": "urma_endpoint.h", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L1"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmatransport", "label": "UrmaTransport", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L42", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmahandshake", "label": "UrmaHandshake", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L46", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_parsedhello", "label": "ParsedHello", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L47", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect", "label": "UrmaConnect", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L56", "_callable": true}, {"id": "appconnect", "label": "AppConnect", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "label": "StartConnect", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L59"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_stopconnect", "label": "StopConnect", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L61"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_run", "label": "Run", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L70"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_data", "label": "_data", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L72"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_error", "label": "_error", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L73"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "label": "UrmaResource", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L81", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_next", "label": "next", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L82"}, {"id": "urma_jfc_t", "label": "urma_jfc_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_jfc", "label": "jfc", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L84"}, {"id": "urma_jfce_t", "label": "urma_jfce_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_jfce", "label": "jfce", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L85"}, {"id": "urma_jfr_t", "label": "urma_jfr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_jfr", "label": "jfr", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L86"}, {"id": "urma_jetty_t", "label": "urma_jetty_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_jetty", "label": "jetty", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L87"}, {"id": "urma_target_jetty_t", "label": "urma_target_jetty_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_remote_jetty", "label": "remote_jetty", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L89"}, {"id": "urma_target_seg_t", "label": "urma_target_seg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_remote_seg", "label": "remote_seg", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L90"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "label": ".UrmaResource()", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L92", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint", "label": "UrmaEndpoint()", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L100", "_callable": true}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "cstdint", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L21", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "functional", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L22", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "vector", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L23", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "atomicops", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L25", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "iobuf", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L26", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "macros", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L27", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "mpsc_queue", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L28", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "types", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L29", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "socket", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L31", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "urma_api", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L35", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "urma_types", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L36", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "urma_handshake", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L37", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "urma_handshake", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L38", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmatransport", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L42", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmahandshake", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L46", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_parsedhello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L47", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L56", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect", "target": "appconnect", "relation": "inherits", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L56", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L59", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_stopconnect", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L61", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_run", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L70", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_data", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L72", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_error", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L73", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L81", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_next", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L82", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L84", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_jfc", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L84", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "urma_jfce_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L85", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_jfce", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L85", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "urma_jfr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L86", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_jfr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L86", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "urma_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L87", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_jetty", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L87", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "urma_target_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L89", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_remote_jetty", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L89", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L90", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_remote_seg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L90", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L92", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L100", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L344", "weight": 1.0}], "raw_calls": [{"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint", "callee": "DISALLOW_COPY_AND_ASSIGN", "is_member_call": false, "source_file": "urma_endpoint.h", "source_location": "L334", "receiver": null, "lang": "cpp"}], "cpp_type_table": {"path": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.h", "table": {"_rbuf": "IOBuf>", "_sbuf": "IOBuf>", "_cq_sid": "SocketId", "_resource": "UrmaResource", "_socket": "Socket"}}}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/9ead6eae6b7ea7f4b18e3757e1e7d33a73a6879dca40078e12765880de1061a1.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/9ead6eae6b7ea7f4b18e3757e1e7d33a73a6879dca40078e12765880de1061a1.json
new file mode 100644
index 0000000000..52450abd22
--- /dev/null
+++ b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/9ead6eae6b7ea7f4b18e3757e1e7d33a73a6879dca40078e12765880de1061a1.json
@@ -0,0 +1 @@
+{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "label": "urma_handshake.h", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L1"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "label": "UrmaEndpoint", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L32", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "label": "ParsedHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L38", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_buffer_size", "label": "buffer_size", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L39"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_recv_buffer_cnt", "label": "recv_buffer_cnt", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L40"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_jetty_id", "label": "jetty_id", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L41"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_eid", "label": "eid", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L42"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_uasid", "label": "uasid", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L43"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_tp_type", "label": "tp_type", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L44"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_eid", "label": "seg_eid", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L47"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_uasid", "label": "seg_uasid", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L48"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_va", "label": "seg_va", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L49"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_len", "label": "seg_len", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L50"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_token_id", "label": "seg_token_id", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L51"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "label": "HelloMessage", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L73", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_msg_len", "label": "msg_len", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L74"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_hello_ver", "label": "hello_ver", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L75"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_impl_ver", "label": "impl_ver", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L76"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_buffer_size", "label": "buffer_size", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L77"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_recv_buffer_cnt", "label": "recv_buffer_cnt", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L78"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_jetty_id", "label": "jetty_id", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L79"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_eid", "label": "eid", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L80"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_uasid", "label": "uasid", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L81"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_tp_type", "label": "tp_type", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L82"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_pad", "label": "pad", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L83"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_eid", "label": "seg_eid", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L84"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_uasid", "label": "seg_uasid", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L85"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_va", "label": "seg_va", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L86"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_len", "label": "seg_len", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L87"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_token_id", "label": "seg_token_id", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L88"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "label": "Serialize", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L90"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "label": "Deserialize", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L91"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "label": "UrmaHandshake", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L97", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake_urmahandshake", "label": ".~UrmaHandshake()", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L99", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake_protocolversion", "label": "ProtocolVersion", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L100"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake_sendlocalhello", "label": "SendLocalHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L104"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake_receiveandparseremotehello", "label": "ReceiveAndParseRemoteHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L110"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2", "label": "UrmaHandshakeClientV2", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L114", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_urmahandshakeclientv2", "label": ".UrmaHandshakeClientV2()", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L116", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_protocolversion", "label": ".ProtocolVersion()", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L117", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_sendlocalhello", "label": "SendLocalHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L118"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_receiveandparseremotehello", "label": "ReceiveAndParseRemoteHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L119"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_ep", "label": "_ep", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L121"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2", "label": "UrmaHandshakeServerV2", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L124", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_urmahandshakeserverv2", "label": ".UrmaHandshakeServerV2()", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L126", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_protocolversion", "label": ".ProtocolVersion()", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L127", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "label": "SendLocalHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L128"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_receiveandparseremotehello", "label": "ReceiveAndParseRemoteHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L129"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_ep", "label": "_ep", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L131"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3", "label": "UrmaHandshakeClientV3", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L135", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_urmahandshakeclientv3", "label": ".UrmaHandshakeClientV3()", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L137", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_protocolversion", "label": ".ProtocolVersion()", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L138", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_sendlocalhello", "label": "SendLocalHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L139"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_receiveandparseremotehello", "label": "ReceiveAndParseRemoteHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L140"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_ep", "label": "_ep", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L142"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3", "label": "UrmaHandshakeServerV3", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L145", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_urmahandshakeserverv3", "label": ".UrmaHandshakeServerV3()", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L147", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_protocolversion", "label": ".ProtocolVersion()", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L148", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_sendlocalhello", "label": "SendLocalHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L149"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_receiveandparseremotehello", "label": "ReceiveAndParseRemoteHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L150"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_ep", "label": "_ep", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L152"}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "cstdint", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L21", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "cstring", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L22", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "string", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L23", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "urma_types", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L27", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L32", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L38", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_buffer_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L39", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_recv_buffer_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L40", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_jetty_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L41", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L42", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_uasid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L43", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_tp_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L44", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L47", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_uasid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L48", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_va", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L49", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L50", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_token_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L51", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L73", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_msg_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L74", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_hello_ver", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L75", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_impl_ver", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L76", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_buffer_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L77", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_recv_buffer_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L78", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_jetty_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L79", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L80", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_uasid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L81", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_tp_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L82", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_pad", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L83", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L84", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_uasid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L85", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_va", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L86", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L87", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_token_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L88", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L90", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L91", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L97", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake_urmahandshake", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L99", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake_protocolversion", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L100", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake_sendlocalhello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L104", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake_receiveandparseremotehello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L110", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L114", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "relation": "inherits", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L114", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_urmahandshakeclientv2", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L116", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_urmahandshakeclientv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L116", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_protocolversion", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L117", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_sendlocalhello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L118", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_receiveandparseremotehello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L119", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L121", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_ep", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L121", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L124", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "relation": "inherits", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L124", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_urmahandshakeserverv2", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L126", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_urmahandshakeserverv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L126", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_protocolversion", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L127", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L128", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_receiveandparseremotehello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L129", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L131", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_ep", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L131", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L135", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "relation": "inherits", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L135", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_urmahandshakeclientv3", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L137", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_urmahandshakeclientv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L137", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_protocolversion", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L138", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_sendlocalhello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L139", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_receiveandparseremotehello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L140", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L142", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_ep", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L142", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L145", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "relation": "inherits", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L145", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_urmahandshakeserverv3", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L147", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_urmahandshakeserverv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L147", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_protocolversion", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L148", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_sendlocalhello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L149", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_receiveandparseremotehello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L150", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L152", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_ep", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L152", "weight": 1.0, "context": "field"}], "raw_calls": []}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/bb7775d86173e02925fc786db010956f4dd08aef5a92ffdbffd70a11effd1833.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/bb7775d86173e02925fc786db010956f4dd08aef5a92ffdbffd70a11effd1833.json
new file mode 100644
index 0000000000..3373b3214b
--- /dev/null
+++ b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/bb7775d86173e02925fc786db010956f4dd08aef5a92ffdbffd70a11effd1833.json
@@ -0,0 +1 @@
+{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "label": "urma_endpoint.cpp", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjetty", "label": "PreparedJetty", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L82", "_callable": true}, {"id": "urmaresource", "label": "UrmaResource", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjetty_res", "label": "res", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L83"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjettycount", "label": "PreparedJettyCount()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L89", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "label": "UrmaResource::~UrmaResource()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L125", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_urmaendpoint", "label": "UrmaEndpoint::UrmaEndpoint()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L138", "_callable": true}, {"id": "socket", "label": "Socket", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "label": "UrmaEndpoint::Reset()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L159", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readfromfd", "label": "UrmaEndpoint::ReadFromFd()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L188", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pushbacktoreadbuf", "label": "UrmaEndpoint::PushBackToReadBuf()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L215", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "label": "UrmaEndpoint::WriteToFd()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L219", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_makelocalparsedhello", "label": "UrmaEndpoint::MakeLocalParsedHello()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L239", "_callable": true}, {"id": "parsedhello", "label": "ParsedHello", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov2", "label": "UrmaEndpoint::FillLocalHelloV2()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L261", "_callable": true}, {"id": "hellomessage", "label": "HelloMessage", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "label": "UrmaEndpoint::FillLocalHelloV3()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L282", "_callable": true}, {"id": "urmahello", "label": "UrmaHello", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "label": "UrmaEndpoint::WriteHelloV3()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L298", "_callable": true}, {"id": "iobuf", "label": "IOBuf", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "label": "UrmaEndpoint::ReadAndParseHelloV3()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L327", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "label": "UrmaEndpoint::AllocateResources()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L360", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_deallocateresources", "label": "UrmaEndpoint::DeallocateResources()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L462", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "label": "UrmaEndpoint::ImportPeer()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L494", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf", "label": "UrmaIOBuf", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L546", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "label": ".cut_into_sglist()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L556", "_callable": true}, {"id": "urma_sge_t", "label": "urma_sge_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "label": "UrmaEndpoint::CutFromIOBufList()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L590", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_iswritable", "label": "UrmaEndpoint::IsWritable()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L664", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_dopostrecv", "label": "UrmaEndpoint::DoPostRecv()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L673", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_postrecv", "label": "UrmaEndpoint::PostRecv()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L687", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendimm", "label": "UrmaEndpoint::SendImm()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L727", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendack", "label": "UrmaEndpoint::SendAck()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L751", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "label": "UrmaEndpoint::HandleCompletion()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L761", "_callable": true}, {"id": "urma_cr_t", "label": "urma_cr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "label": "UrmaEndpoint::PollCq()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L847", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_applyremotehello", "label": "UrmaEndpoint::ApplyRemoteHello()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L930", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "label": "UrmaEndpoint::OnNewDataFromTcp()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L953", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_tryreadontcp", "label": "UrmaEndpoint::TryReadOnTcp()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1010", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "label": "TryReadOnTcpDuringUrmaEst()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1016", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_fallbacktotcp", "label": "UrmaEndpoint::FallbackToTcp()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1042", "_callable": true}, {"id": "urmatransport", "label": "UrmaTransport", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "label": "UrmaEndpoint::FailHandshake()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1051", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "label": "UrmaEndpoint::ProcessHandshakeAtClient()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1072", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "label": "UrmaEndpoint::ProcessHandshakeAtServer()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1144", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "label": "UrmaConnect::StartConnect()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1240", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_stopconnect", "label": "UrmaConnect::StopConnect()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1279", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_run", "label": "UrmaConnect::Run()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1281", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_getstatestr", "label": "UrmaEndpoint::GetStateStr()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1293", "_callable": true}, {"id": "string", "label": "string", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_debuginfo", "label": "UrmaEndpoint::DebugInfo()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1313", "_callable": true}, {"id": "ostream", "label": "ostream", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "stringpiece", "label": "StringPiece", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "label": "UrmaEndpoint::WaitCqEvent()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1322", "_callable": true}, {"id": "socketuniqueptr", "label": "SocketUniquePtr", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "urma_jfc_t", "label": "urma_jfc_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reqnotifycq", "label": "UrmaEndpoint::ReqNotifyCq()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1353", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "label": "UrmaEndpoint::PollingModeInitialize()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1368", "_callable": true}, {"id": "bthread_tag_t", "label": "bthread_tag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "function", "label": "function", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmoderelease", "label": "UrmaEndpoint::PollingModeRelease()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1462", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_polleraddcqsid", "label": "UrmaEndpoint::PollerAddCqSid()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1476", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollerremovecqsid", "label": "UrmaEndpoint::PollerRemoveCqSid()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1492", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "label": "UrmaEndpoint::GlobalInitialize()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1505", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalrelease", "label": "UrmaEndpoint::GlobalRelease()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1566", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_bringupjetty", "label": "UrmaEndpoint::BringUpJetty()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1581", "_callable": true}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "urma_endpoint", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L18", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "algorithm", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L22", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "cstring", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L23", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "iostream", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L24", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "memory", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L25", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "string", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L26", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "unordered_set", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L27", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "utility", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L28", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "vector", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L29", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "resource", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L30", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "unistd", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L31", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "gflags", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L33", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "atomicops", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L35", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "iobuf", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L36", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "logging", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L37", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "macros", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L38", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "sys_byteorder", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L39", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "time", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L40", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "bthread", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L41", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "butex", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L42", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "input_messenger", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L44", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "socket", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L45", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "urma_api", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L46", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "urma_endpoint", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L47", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "urma_handshake", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L48", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "urma_handshake", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L49", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "urma_helper", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L50", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "urma_transport", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L51", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L82", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjetty", "target": "urmaresource", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L83", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjetty_res", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L83", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjettycount", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L89", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L125", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_urmaendpoint", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L138", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_urmaendpoint", "target": "socket", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L138", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_urmaendpoint", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L151", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L159", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readfromfd", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L188", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pushbacktoreadbuf", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L215", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L219", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_makelocalparsedhello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L239", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_makelocalparsedhello", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L239", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov2", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L261", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov2", "target": "hellomessage", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L261", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L282", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "target": "urmahello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L282", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L298", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "target": "urmahello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L298", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L312", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "target": "iobuf", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L312", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L327", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L327", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L360", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_deallocateresources", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L462", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L494", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L494", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L546", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf", "target": "iobuf", "relation": "inherits", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L546", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L556", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "target": "urma_sge_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L556", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "target": "iobuf", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L556", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L590", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "target": "iobuf", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L590", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_iswritable", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L664", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_dopostrecv", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L673", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_postrecv", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L687", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendimm", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L727", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendack", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L751", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L761", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "target": "urma_cr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L761", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L847", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "target": "socket", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L847", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_applyremotehello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L930", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_applyremotehello", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L930", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L953", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "target": "socket", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L953", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_tryreadontcp", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1010", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1016", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "target": "socket", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1016", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_fallbacktotcp", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1042", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_fallbacktotcp", "target": "urmatransport", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1042", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1051", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "target": "urmatransport", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1051", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1072", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1144", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1240", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "target": "socket", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1240", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_stopconnect", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1279", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_stopconnect", "target": "socket", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1279", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_run", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1281", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_getstatestr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1293", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_getstatestr", "target": "string", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1293", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_debuginfo", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1313", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_debuginfo", "target": "ostream", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1313", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_debuginfo", "target": "stringpiece", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1313", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1322", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "target": "socketuniqueptr", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1322", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1322", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reqnotifycq", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1353", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1368", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "target": "bthread_tag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1368", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "target": "function", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1368", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "target": "function", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1368", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "target": "function", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1368", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmoderelease", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1462", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmoderelease", "target": "bthread_tag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1462", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_polleraddcqsid", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1476", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollerremovecqsid", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1492", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1505", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalrelease", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1566", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_bringupjetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1581", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L622", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1003", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjettycount", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1521", "weight": 1.0}], "raw_calls": [{"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjettycount", "callee": "getrlimit", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L97", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjettycount", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L113", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "callee": "urma_unimport_jetty", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L126", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "callee": "urma_unimport_seg", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L127", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "callee": "urma_delete_jetty", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L128", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "callee": "urma_delete_jfr", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L129", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "callee": "urma_delete_jfc", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L130", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "callee": "urma_delete_jfce", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L131", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_urmaendpoint", "callee": "butex_create_checked<butil::atomic<int>>", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L147", "receiver": "bthread", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_urmaendpoint", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L148", "receiver": "_read_butex", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_urmaendpoint", "callee": "DeallocateResources", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L152", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_urmaendpoint", "callee": "butex_destroy", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L154", "receiver": "bthread", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "callee": "DeallocateResources", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L160", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L166", "receiver": "_remote_rq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L167", "receiver": "_sq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L168", "receiver": "_new_rq_wrs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "callee": "clear", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L177", "receiver": "_sbuf", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "callee": "clear", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L178", "receiver": "_rbuf", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "callee": "clear", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L179", "receiver": "_rbuf_data", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L180", "receiver": "_read_butex", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readfromfd", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L192", "receiver": "_read_butex", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readfromfd", "callee": "milliseconds_from_now", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L193", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readfromfd", "callee": "fd", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L194", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readfromfd", "callee": "read", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L195", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readfromfd", "callee": "butex_wait", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L198", "receiver": "bthread", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pushbacktoreadbuf", "callee": "append", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L216", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "callee": "milliseconds_from_now", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L223", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "callee": "fd", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L224", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "callee": "write", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L225", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "callee": "WaitEpollOut", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L228", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_makelocalparsedhello", "callee": "GetUrmaRecvBlockSize", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L241", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_makelocalparsedhello", "callee": "memcpy", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L246", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_makelocalparsedhello", "callee": "GetPoolSegFor", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L251", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_makelocalparsedhello", "callee": "memcpy", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L253", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov2", "callee": "MakeLocalParsedHello", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L267", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov2", "callee": "memcpy", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L272", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov2", "callee": "memcpy", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L275", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "MakeLocalParsedHello", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L284", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_buffer_size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L285", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_recv_buffer_cnt", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L286", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_jetty_id", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L287", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_eid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L288", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_uasid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L289", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_tp_type", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L290", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_seg_eid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L291", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_seg_uasid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L292", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_seg_va", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L293", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_seg_len", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L294", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_seg_token_id", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L295", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "callee": "append", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L300", "receiver": "packet", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "callee": "SerializeToString", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L302", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L303", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "callee": "HostToNet32", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L306", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L306", "receiver": "body", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "callee": "append", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L307", "receiver": "packet", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "callee": "append", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L308", "receiver": "packet", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "callee": "WriteToFd", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L309", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "callee": "empty", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L314", "receiver": "data", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "callee": "milliseconds_from_now", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L315", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "callee": "fd", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L316", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "callee": "cut_into_file_descriptor", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L317", "receiver": "data", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "callee": "WaitEpollOut", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L320", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "ReadFromFd", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L330", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "NetToHost32", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L331", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "ReadFromFd", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L334", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "ParseFromArray", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L336", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "data", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L336", "receiver": "body", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L336", "receiver": "body", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L339", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "eid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L339", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L339", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "seg_eid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L339", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "buffer_size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L340", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "recv_buffer_cnt", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L341", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "jetty_id", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L342", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "memcpy", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L343", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "data", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L343", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "eid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L343", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "uasid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L344", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "tp_type", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L345", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "memcpy", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L346", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "data", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L346", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "seg_eid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L346", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "seg_uasid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L347", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "seg_va", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L348", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "seg_len", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L349", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "seg_token_id", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L350", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "ValidHello", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L351", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "GetUrmaContext", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L362", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "BAIDU_SCOPED_LOCK", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L371", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "urma_create_jfce", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L385", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L388", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "urma_create_jfc", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L396", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "PLOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L397", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "urma_create_jfr", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L405", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "PLOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L406", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "GetUrmaMaxSge", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L414", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "urma_create_jetty", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L420", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "PLOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L421", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "resize", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L424", "receiver": "_sbuf", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "resize", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L425", "receiver": "_rbuf", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "resize", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L426", "receiver": "_rbuf_data", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L431", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "ReqNotifyCq", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L435", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "keytable_pool", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L440", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "Create", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L443", "receiver": "Socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "PLOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L444", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "keytable_pool", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L451", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "Create", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L453", "receiver": "Socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "PLOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L454", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "PollerAddCqSid", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L457", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_deallocateresources", "callee": "PollerRemoveCqSid", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L466", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_deallocateresources", "callee": "Address", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L472", "receiver": "Socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_deallocateresources", "callee": "fd", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L473", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_deallocateresources", "callee": "RemoveConsumer", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L474", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_deallocateresources", "callee": "SetFailed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L478", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "callee": "GetUrmaContext", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L495", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "callee": "memcpy", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L502", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "callee": "urma_import_seg", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L512", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "callee": "PLOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L514", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "callee": "memcpy", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L520", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "callee": "urma_import_jetty", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L532", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "callee": "PLOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L534", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "callee": "_ref_num", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L560", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "callee": "_ref_at", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L561", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "callee": "fetch1", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L562", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "callee": "GetPoolSegFor", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L564", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "callee": "get_first_data_meta", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L567", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "callee": "cutn", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L582", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "GetUrmaMaxSge", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L595", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "alloca", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L599", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L605", "receiver": "_remote_rq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L606", "receiver": "_sq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "GetUrmaRecvBlockSize", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L617", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "empty", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L621", "receiver": "data", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "memset", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L631", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "exchange", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L633", "receiver": "_new_rq_wrs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "urma_post_jetty_send_wr", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L642", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "fetch_add", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L644", "receiver": "_new_rq_wrs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L645", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "GetUrmaMaxSge", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L647", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L652", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L655", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "fetch_sub", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L657", "receiver": "_remote_rq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "fetch_sub", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L658", "receiver": "_sq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_iswritable", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L665", "receiver": "_remote_rq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_iswritable", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L666", "receiver": "_sq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_dopostrecv", "callee": "GetPoolSegFor", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L674", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_dopostrecv", "callee": "urma_post_jfr_wr", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L681", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_postrecv", "callee": "GetUrmaRecvBlockSize", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L689", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_postrecv", "callee": "clear", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L691", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_postrecv", "callee": "Next", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L696", "receiver": "zcis", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_postrecv", "callee": "DoPostRecv", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L702", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_postrecv", "callee": "clear", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L705", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_postrecv", "callee": "Next", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L711", "receiver": "zcos", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_postrecv", "callee": "DoPostRecv", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L718", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendimm", "callee": "memset", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L735", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendimm", "callee": "urma_post_jetty_send_wr", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L743", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendimm", "callee": "fetch_add", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L744", "receiver": "_new_rq_wrs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendack", "callee": "fetch_add", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L753", "receiver": "_new_rq_wrs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendack", "callee": "SendImm", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L756", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendack", "callee": "exchange", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L756", "receiver": "_new_rq_wrs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L763", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L771", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L773", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "SendAck", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L782", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "clear", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L787", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "subtle::MemoryBarrier", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L790", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "fetch_add", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L791", "receiver": "_sq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L792", "receiver": "_remote_rq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "WakeAsEpollOut", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L794", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L801", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L807", "receiver": "_remote_rq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L810", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "compare_exchange_weak", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L814", "receiver": "_remote_rq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L820", "receiver": "_sq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "WakeAsEpollOut", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L821", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L824", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "GetUrmaRecvBlockSize", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L828", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L829", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "cutn", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L838", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "append", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L840", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "PostRecv", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L842", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "SendAck", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L843", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "user", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L848", "receiver": "m", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "Address", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L851", "receiver": "Socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "Failed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L852", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "WaitCqEvent", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L856", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "min<int>", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L866", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "urma_poll_jfc", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L868", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L874", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L876", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "Failed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L878", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "HandleCompletion", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L882", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "urma_ack_jfc", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L896", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "ReqNotifyCq", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L897", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "Failed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L902", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "SetFailed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L903", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "cpuwide_time_us", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L908", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "gettimeofday_us", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L909", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "user", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L910", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "ProcessNewMessage", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L913", "receiver": "messenger", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L913", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L915", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L918", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L920", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L921", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_applyremotehello", "callee": "min<uint32_t>", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L934", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_applyremotehello", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L942", "receiver": "_remote_rq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_applyremotehello", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L944", "receiver": "_sq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L954", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "OnNewMessages", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L961", "receiver": "InputMessenger", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L967", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "CreatedByConnect", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L969", "receiver": "m", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "IsUrmaAvailable", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L971", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "OnNewMessages", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L974", "receiver": "InputMessenger", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "ReAddress", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L978", "receiver": "m", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "bthread_attr_set_name", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L982", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "bthread_start_background", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L983", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L986", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "release", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L988", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "fetch_add", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L996", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "butex_wake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L997", "receiver": "bthread", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "OnNewMessages", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1000", "receiver": "InputMessenger", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "MoreReadEvents", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1006", "receiver": "m", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_tryreadontcp", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1011", "receiver": "_state", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_tryreadontcp", "callee": "OnNewMessages", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1012", "receiver": "InputMessenger", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "callee": "read", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1020", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "callee": "fd", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1020", "receiver": "socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "callee": "SetFailed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1024", "receiver": "socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "callee": "berror", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1025", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "callee": "MoreReadEvents", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1028", "receiver": "socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "callee": "SetEOF", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1032", "receiver": "socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "callee": "SetFailed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1035", "receiver": "socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_fallbacktotcp", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1044", "receiver": "_state", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_fallbacktotcp", "callee": "DeallocateResources", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1045", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_fallbacktotcp", "callee": "TryReadOnTcp", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1047", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1053", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "callee": "GetStateStr", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1053", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1054", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "callee": "berror", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1056", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1058", "receiver": "_state", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "callee": "DeallocateResources", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1059", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1061", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "callee": "SetFailed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1065", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1075", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1076", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1077", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1078", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "IsUrmaAvailable", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1079", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "FallbackToTcp", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1080", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "AllocateResources", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1084", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "FallbackToTcp", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1085", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "PostRecv", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1089", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "FallbackToTcp", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1090", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1093", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1094", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "ProtocolVersion", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1097", "receiver": "hs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "SendLocalHello", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1098", "receiver": "hs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1100", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1103", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1104", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "ReceiveAndParseRemoteHello", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1108", "receiver": "hs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1110", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "FallbackToTcp", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1114", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1117", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1118", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "ApplyRemoteHello", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1119", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "ImportPeer", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1121", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1123", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1126", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1127", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "HostToNet32", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1130", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "WriteToFd", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1131", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1133", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1138", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1140", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1147", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1148", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1149", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1150", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "ReadFromFd", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1153", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1155", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "PushBackToReadBuf", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1161", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FallbackToTcp", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1162", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "ProtocolVersion", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1165", "receiver": "hs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "ReceiveAndParseRemoteHello", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1168", "receiver": "hs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1170", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1174", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1177", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1178", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "AllocateResources", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1180", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1182", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "PostRecv", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1185", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1187", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1190", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1191", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "ApplyRemoteHello", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1192", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "ImportPeer", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1194", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1196", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1199", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1200", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "SendLocalHello", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1202", "receiver": "hs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1204", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1207", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1208", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "ReadFromFd", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1211", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1213", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "NetToHost32", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1216", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1219", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1222", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1227", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1229", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FallbackToTcp", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1231", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "callee": "Address", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1243", "receiver": "Socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1249", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "callee": "Run", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1251", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "callee": "IsUrmaAvailable", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1254", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "callee": "Run", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1260", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "callee": "bthread_attr_set_name", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1265", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "callee": "bthread_start_background", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1266", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "callee": "Run", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1271", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "callee": "release", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1275", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_run", "callee": "cb", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1285", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_getstatestr", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1294", "receiver": "_state", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_debuginfo", "callee": "GetStateStr", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1314", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_debuginfo", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1317", "receiver": "_sq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_debuginfo", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1318", "receiver": "_remote_rq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "urma_wait_jfc", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1329", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "PLOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1335", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1336", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "SetFailed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1337", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "berror", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1338", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1343", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1343", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "SetFailed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1345", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1348", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1349", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reqnotifycq", "callee": "urma_rearm_jfc", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1358", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reqnotifycq", "callee": "PLOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1361", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reqnotifycq", "callee": "SetFailed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1362", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reqnotifycq", "callee": "berror", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1362", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1374", "receiver": "_poller_groups", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "empty", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1375", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "compare_exchange_strong", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1381", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "init_fn", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1396", "receiver": "poller", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1398", "receiver": "running", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "Dequeue", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1399", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "emplace", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1401", "receiver": "cq_sids", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "erase", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1403", "receiver": "cq_sids", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "Address", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1408", "receiver": "Socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "PollCq", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1409", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1409", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "callback", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1413", "receiver": "poller", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "empty", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1415", "receiver": "cq_sids", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "bthread_yield", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1416", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "release_fn", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1420", "receiver": "poller", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1426", "receiver": "pollers", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1433", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "bthread_join", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1435", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "bthread_attr_set_name", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1445", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "bthread_start_background", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1446", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1447", "receiver": "args", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1449", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "bthread_join", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1451", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "release", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1457", "receiver": "args", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmoderelease", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1463", "receiver": "_poller_groups", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmoderelease", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1467", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmoderelease", "callee": "bthread_join", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1470", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_polleraddcqsid", "callee": "empty", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1477", "receiver": "_poller_groups", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_polleraddcqsid", "callee": "bthread_self_tag", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1480", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_polleraddcqsid", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1481", "receiver": "_poller_groups", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_polleraddcqsid", "callee": "empty", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1485", "receiver": "pollers", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_polleraddcqsid", "callee": "fmix32", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1487", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_polleraddcqsid", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1487", "receiver": "pollers", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_polleraddcqsid", "callee": "Enqueue", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1488", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollerremovecqsid", "callee": "empty", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1493", "receiver": "_poller_groups", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollerremovecqsid", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1494", "receiver": "_poller_groups", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollerremovecqsid", "callee": "empty", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1498", "receiver": "pollers", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollerremovecqsid", "callee": "fmix32", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1500", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollerremovecqsid", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1500", "receiver": "pollers", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollerremovecqsid", "callee": "Enqueue", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1501", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "empty", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1508", "receiver": "_poller_groups", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1510", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "vector<PollerGroup>", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1516", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "GetUrmaContext", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1519", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "urma_create_jfce", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1525", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "urma_create_jfc", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1534", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "urma_create_jfr", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1542", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "GetUrmaMaxSge", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1550", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "urma_create_jetty", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1556", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1562", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalrelease", "callee": "BAIDU_SCOPED_LOCK", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1568", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalrelease", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1576", "receiver": "_poller_groups", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalrelease", "callee": "PollingModeRelease", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1577", "receiver": null, "lang": "cpp"}], "cpp_type_table": {"path": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp", "table": {"p": "ParsedHello", "packet": "IOBuf", "msg": "UrmaHello", "options": "SocketOptions", "next": "UrmaResource", "s": "SocketUniquePtr", "r": "BlockRef", "to": "IOBuf", "zcos": "IOBufAsZeroCopyOutputStream", "zcis": "IOBufAsZeroCopyOutputStream", "last_msg": "InputMessageClosure", "state": "State", "ep": "UrmaEndpoint", "remote": "ParsedHello", "guard": "RunGuard"}}}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/f822344e09f50ff082a2ebbaa0f37defc274c585af039c0e7b995bfe7f0bf804.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/f822344e09f50ff082a2ebbaa0f37defc274c585af039c0e7b995bfe7f0bf804.json
new file mode 100644
index 0000000000..fa3caa7fdb
--- /dev/null
+++ b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/f822344e09f50ff082a2ebbaa0f37defc274c585af039c0e7b995bfe7f0bf804.json
@@ -0,0 +1 @@
+{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_api_h", "label": "urma_api.h", "file_type": "code", "source_file": "sdk/urma/urma_api.h", "source_location": "L1"}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_api_h", "target": "stdbool", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_api.h", "source_location": "L13", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_api_h", "target": "stdint", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_api.h", "source_location": "L14", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_api_h", "target": "urma_types", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_api.h", "source_location": "L16", "weight": 1.0}], "raw_calls": []}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/stat-index.json b/src/brpc/urma/graphify-out/cache/stat-index.json
new file mode 100644
index 0000000000..6e429df537
--- /dev/null
+++ b/src/brpc/urma/graphify-out/cache/stat-index.json
@@ -0,0 +1 @@
+{"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp":{"size":22422,"mtime_ns":1785291503405746700,"word_count":2055,"hashes":{"mock_urma.cpp":"608feeb18131c6633a1d3bae5ce1bdaf944a337cafc10e12152fa2915751f7d0"}},"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_api.h":{"size":47786,"mtime_ns":1785227626464076200,"word_count":6750,"hashes":{"sdk/urma/urma_api.h":"f822344e09f50ff082a2ebbaa0f37defc274c585af039c0e7b995bfe7f0bf804"}},"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_opcode.h":{"size":10591,"mtime_ns":1785226861704155300,"word_count":1138,"hashes":{"sdk/urma/urma_opcode.h":"01ccfd37e3d64cd110462f1203e0d20642510e3e3d14a570a041257996772a31"}},"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h":{"size":54318,"mtime_ns":1785227626506547800,"word_count":6079,"hashes":{"sdk/urma/urma_types.h":"6870b34881c2bda6a7406307467705c41b2381b7a5af286fab00d3241d6a5eca"}},"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp":{"size":58559,"mtime_ns":1785309099990290300,"word_count":5389,"hashes":{"urma_endpoint.cpp":"bb7775d86173e02925fc786db010956f4dd08aef5a92ffdbffd70a11effd1833"}},"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.h":{"size":13432,"mtime_ns":1785309036527955400,"word_count":1577,"hashes":{"urma_endpoint.h":"7899e48f9378edf160c448d2d8eb8cdaa14683461e3f2562a4ce8dedce8721ed"}},"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_handshake.cpp":{"size":11297,"mtime_ns":1785291857383725700,"word_count":1138,"hashes":{"urma_handshake.cpp":"3dcbdee4a792ca85149ae0eada9ea3f39bb1c3f972074cfdeb983ed964bc1f54"}},"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_handshake.h":{"size":6762,"mtime_ns":1785291144209111300,"word_count":893,"hashes":{"urma_handshake.h":"9ead6eae6b7ea7f4b18e3757e1e7d33a73a6879dca40078e12765880de1061a1"}},"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp":{"size":24053,"mtime_ns":1785307850782229900,"word_count":2487,"hashes":{"urma_helper.cpp":"5af18e30c1f05aae06e4f45bf09d4d6ab3654daf64631c4821071a362adf2f1e"}},"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.h":{"size":3392,"mtime_ns":1785290825559803600,"word_count":452,"hashes":{"urma_helper.h":"1df09f4812201fd3151eb13e804615a74b896364be016d8a28ec657f714e1422"}}}
\ No newline at end of file
diff --git a/test/brpc_rdma_unittest.cpp b/test/brpc_rdma_unittest.cpp
index 06a0c07fa0..7b556324a8 100644
--- a/test/brpc_rdma_unittest.cpp
+++ b/test/brpc_rdma_unittest.cpp
@@ -36,6 +36,7 @@
 #include "brpc/parallel_channel.h"
 #include "brpc/selective_channel.h"
 #include "brpc/rdma_transport.h"
+#include "brpc/adapter_transport.h"
 #include "brpc/rdma/block_pool.h"
 #include "brpc/rdma/rdma_endpoint.h"
 #include "brpc/handshake/rdma_handshake.h"
@@ -200,7 +201,7 @@ TEST_F(RdmaTest, client_close_before_hello_send) {
     ASSERT_EQ(0, connect(sockfd, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     Socket* s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
     close(sockfd);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -221,7 +222,7 @@ TEST_F(RdmaTest, client_hello_msg_invalid_magic_str) {
     ASSERT_EQ(0, connect(sockfd, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     Socket* s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
 
     uint8_t data[rdma::HELLO_V2_MSG_LEN_MIN];
     memcpy(data, "PRPC", 4);  // send as normal baidu_std protocol
@@ -231,7 +232,7 @@ TEST_F(RdmaTest, client_hello_msg_invalid_magic_str) {
     // and hand the bytes to other protocols; it does not touch the endpoint
     // state, so it stays UNINIT (the old blocking handshake used to set
     // FALLBACK_TCP here).
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
 
     StopServer();
 }
@@ -251,14 +252,14 @@ TEST_F(RdmaTest, client_close_during_hello_send) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
     memcpy(data, "RD", 2);
     ASSERT_EQ(2, write(sockfd1, data, 2));  // break in magic str
     usleep(100000);  // wait for server to handle the msg
     // Fewer than 4 magic bytes: the transport-handshake parser can't tell yet,
     // returns NOT_ENOUGH_DATA and leaves the endpoint UNINIT (the old blocking
-    // handshake used to set S_HELLO_WAIT before reading the magic).
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    // the common handshake state remains uninitialized before reading magic).
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
     close(sockfd1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -268,11 +269,11 @@ TEST_F(RdmaTest, client_close_during_hello_send) {
     ASSERT_EQ(0, connect(sockfd2, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
     memcpy(data, "RDMA", 4);
     ASSERT_EQ(4, write(sockfd2, data, 4));  // break after magic str
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
     close(sockfd2);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -282,7 +283,7 @@ TEST_F(RdmaTest, client_close_during_hello_send) {
     ASSERT_EQ(0, connect(sockfd3, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
     // Send the 4B magic plus a valid msg_len (=40) but no body, so the server
     // recognizes an RDMA v2 hello and waits for the remaining bytes. (A zero
     // msg_len would now be rejected up-front as a protocol error.)
@@ -291,7 +292,7 @@ TEST_F(RdmaTest, client_close_during_hello_send) {
     memcpy(data + 4, &v2_len, sizeof(v2_len));
     ASSERT_EQ(6, write(sockfd3, data, 6));  // magic + msg_len, body missing
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
     close(sockfd3);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -314,11 +315,11 @@ TEST_F(RdmaTest, client_hello_msg_invalid_len) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
     memcpy(data, "RDMA", 4);
     ASSERT_EQ(4, write(sockfd1, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
     memset(data + 4, 0, 36);
     ASSERT_EQ(36, write(sockfd1, data + 4, 36));  // Write invalid length.
     usleep(100000);  // wait for server to handle the msg
@@ -329,11 +330,11 @@ TEST_F(RdmaTest, client_hello_msg_invalid_len) {
     ASSERT_EQ(0, connect(sockfd2, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
     memcpy(data, "RDMA", 4);
     ASSERT_EQ(4, write(sockfd2, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
     uint16_t len = butil::HostToNet16(35);
     memcpy(data + 4, &len, sizeof(len));
     memset(data + 6, 0, 34);
@@ -361,11 +362,11 @@ TEST_F(RdmaTest, client_hello_msg_invalid_version) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
     memcpy(data, "RDMA", 4);
     ASSERT_EQ(4, write(sockfd1, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
     memcpy(data + 4, &len, 2);
     memset(data + 6, 0, 34);
     memcpy(data + 6, &ver, 2);  // hello_ver == 1, impl_ver == 0
@@ -378,12 +379,12 @@ TEST_F(RdmaTest, client_hello_msg_invalid_version) {
     // version check, breaking the intent of this UT.
     ASSERT_EQ(36, write(sockfd1, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ACK_WAIT, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF, RdmaTransport::Get(s)->_rdma_state);
     uint32_t flags = 0;
     ASSERT_EQ(sizeof(flags), write(sockfd1, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FALLBACK_TCP, AdapterTransport::Get(s)->handshake_phase());
     sockfd1.reset(-1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -393,11 +394,11 @@ TEST_F(RdmaTest, client_hello_msg_invalid_version) {
     ASSERT_EQ(0, connect(sockfd2, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
     memcpy(data, "RDMA", 4);
     ASSERT_EQ(4, write(sockfd2, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
     memcpy(data + 4, &len, 2);
     memset(data + 6, 0, 32);
     memcpy(data + 8, &ver, 2);  // hello_ver == 0, impl_ver == 1
@@ -405,11 +406,11 @@ TEST_F(RdmaTest, client_hello_msg_invalid_version) {
     // write from data + 4 instead of data.
     ASSERT_EQ(36, write(sockfd2, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ACK_WAIT, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF, RdmaTransport::Get(s)->_rdma_state);
     ASSERT_EQ(sizeof(flags), write(sockfd2, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FALLBACK_TCP, AdapterTransport::Get(s)->handshake_phase());
     sockfd2.reset(-1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -442,17 +443,17 @@ TEST_F(RdmaTest, client_hello_msg_invalid_sq_rq_block_size) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, write(sockfd1, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(36, write(sockfd1, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ACK_WAIT, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF, RdmaTransport::Get(s)->_rdma_state);
     ASSERT_EQ(sizeof(flags), write(sockfd1, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FALLBACK_TCP, AdapterTransport::Get(s)->handshake_phase());
     sockfd1.reset(-1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -467,17 +468,17 @@ TEST_F(RdmaTest, client_hello_msg_invalid_sq_rq_block_size) {
     ASSERT_EQ(0, connect(sockfd2, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, write(sockfd2, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(36, write(sockfd2, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ACK_WAIT, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF, RdmaTransport::Get(s)->_rdma_state);
     ASSERT_EQ(sizeof(flags), write(sockfd2, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FALLBACK_TCP, AdapterTransport::Get(s)->handshake_phase());
     sockfd2.reset(-1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -492,17 +493,17 @@ TEST_F(RdmaTest, client_hello_msg_invalid_sq_rq_block_size) {
     ASSERT_EQ(0, connect(sockfd3, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, write(sockfd3, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(36, write(sockfd3, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ACK_WAIT, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF, RdmaTransport::Get(s)->_rdma_state);
     ASSERT_EQ(sizeof(flags), write(sockfd3, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FALLBACK_TCP, AdapterTransport::Get(s)->handshake_phase());
     sockfd3.reset(-1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -536,10 +537,10 @@ TEST_F(RdmaTest, client_close_after_qp_build) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(40, write(sockfd1, data, 40));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ACK_WAIT, AdapterTransport::Get(s)->handshake_phase());
     close(sockfd1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -573,17 +574,17 @@ TEST_F(RdmaTest, client_close_during_ack_send) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, write(sockfd1, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(36, write(sockfd1, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ACK_WAIT, AdapterTransport::Get(s)->handshake_phase());
     uint32_t flags = butil::HostToNet32(1);
     ASSERT_EQ(sizeof(flags), write(sockfd1, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::ESTABLISHED, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ESTABLISHED, AdapterTransport::Get(s)->handshake_phase());
     close(sockfd1);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -617,17 +618,17 @@ TEST_F(RdmaTest, client_close_after_ack_send) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, write(sockfd1, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(36, write(sockfd1, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ACK_WAIT, AdapterTransport::Get(s)->handshake_phase());
     uint32_t flags = butil::HostToNet32(0);
     ASSERT_EQ(sizeof(flags), write(sockfd1, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FALLBACK_TCP, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF, RdmaTransport::Get(s)->_rdma_state);
     close(sockfd1);
     usleep(100000);  // wait for server to handle the msg
@@ -638,17 +639,17 @@ TEST_F(RdmaTest, client_close_after_ack_send) {
     ASSERT_EQ(0, connect(sockfd2, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, write(sockfd2, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(36, write(sockfd2, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ACK_WAIT, AdapterTransport::Get(s)->handshake_phase());
     flags = butil::HostToNet32(1);
     ASSERT_EQ(sizeof(flags), write(sockfd2, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::ESTABLISHED, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ESTABLISHED, AdapterTransport::Get(s)->handshake_phase());
     close(sockfd2);
     usleep(100000);  // wait for server to handle the msg
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -682,17 +683,17 @@ TEST_F(RdmaTest, client_send_data_on_tcp_after_ack_send) {
     ASSERT_EQ(0, connect(sockfd1, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, write(sockfd1, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(36, write(sockfd1, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ACK_WAIT, AdapterTransport::Get(s)->handshake_phase());
     uint32_t flags = butil::HostToNet32(0);
     ASSERT_EQ(sizeof(flags), write(sockfd1, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FALLBACK_TCP, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(sizeof(flags), write(sockfd1, &flags, sizeof(flags)));
     usleep(100000);
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -702,17 +703,17 @@ TEST_F(RdmaTest, client_send_data_on_tcp_after_ack_send) {
     ASSERT_EQ(0, connect(sockfd2, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);  // wait for server to handle the msg
     s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, write(sockfd2, data, 4)); // Write magic string.
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(36, write(sockfd2, data + 4, 36));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ACK_WAIT, AdapterTransport::Get(s)->handshake_phase());
     flags = butil::HostToNet32(1);
     ASSERT_EQ(sizeof(flags), write(sockfd2, &flags, sizeof(flags)));
     usleep(100000);  // wait for server to handle the msg
-    ASSERT_EQ(RdmaTransport::ESTABLISHED, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ESTABLISHED, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(sizeof(flags), write(sockfd2, &flags, sizeof(flags)));
     usleep(100000);
     ASSERT_EQ(NULL, GetSocketFromServer(0));
@@ -742,7 +743,7 @@ TEST_F(RdmaTest, server_miss_before_hello_send) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -773,7 +774,7 @@ TEST_F(RdmaTest, server_close_before_hello_send) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -781,7 +782,7 @@ TEST_F(RdmaTest, server_close_before_hello_send) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, read(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     close(acc_fd);
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FAILED, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FAILED, AdapterTransport::Get(s)->handshake_phase());
     bthread_id_join(cntl.call_id());
 
     ASSERT_EQ(EEOF, cntl.ErrorCode());
@@ -809,7 +810,7 @@ TEST_F(RdmaTest, server_miss_during_magic_str) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -844,7 +845,7 @@ TEST_F(RdmaTest, server_close_during_magic_str) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -854,7 +855,7 @@ TEST_F(RdmaTest, server_close_during_magic_str) {
     usleep(100000);
     close(acc_fd);
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FAILED, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FAILED, AdapterTransport::Get(s)->handshake_phase());
     bthread_id_join(cntl.call_id());
 
     ASSERT_EQ(EEOF, cntl.ErrorCode());
@@ -882,7 +883,7 @@ TEST_F(RdmaTest, server_hello_invalid_magic_str) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -890,7 +891,7 @@ TEST_F(RdmaTest, server_hello_invalid_magic_str) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, read(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     ASSERT_EQ(4, write(acc_fd, "ABCD", 4));
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FAILED, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FAILED, AdapterTransport::Get(s)->handshake_phase());
     bthread_id_join(cntl.call_id());
 
     ASSERT_EQ(EPROTO, cntl.ErrorCode());
@@ -918,7 +919,7 @@ TEST_F(RdmaTest, server_miss_during_hello_msg) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -953,7 +954,7 @@ TEST_F(RdmaTest, server_close_during_hello_msg) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -963,7 +964,7 @@ TEST_F(RdmaTest, server_close_during_hello_msg) {
     ASSERT_EQ(2, write(acc_fd, "00", 2));
     close(acc_fd);
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FAILED, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FAILED, AdapterTransport::Get(s)->handshake_phase());
     bthread_id_join(cntl.call_id());
 
     ASSERT_EQ(EEOF, cntl.ErrorCode());
@@ -991,7 +992,7 @@ TEST_F(RdmaTest, server_hello_invalid_msg_len) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -1003,7 +1004,7 @@ TEST_F(RdmaTest, server_hello_invalid_msg_len) {
     memset(data + 6, 0, 32);
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FAILED, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FAILED, AdapterTransport::Get(s)->handshake_phase());
     bthread_id_join(cntl.call_id());
 
     ASSERT_EQ(EPROTO, cntl.ErrorCode());
@@ -1031,7 +1032,7 @@ TEST_F(RdmaTest, server_hello_invalid_version) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -1043,7 +1044,7 @@ TEST_F(RdmaTest, server_hello_invalid_version) {
     memset(data + 6, 0, 32);
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FALLBACK_TCP, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, read(acc_fd, data, 4));
     uint32_t* tmp = (uint32_t*)data;
     ASSERT_EQ(0, butil::NetToHost32(*tmp));
@@ -1074,7 +1075,7 @@ TEST_F(RdmaTest, server_hello_invalid_sq_rq_size) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -1095,7 +1096,7 @@ TEST_F(RdmaTest, server_hello_invalid_sq_rq_size) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
 
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FALLBACK_TCP, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, read(acc_fd, data, 4));
     uint32_t* tmp = (uint32_t*)data;
     ASSERT_EQ(0, butil::NetToHost32(*tmp));
@@ -1126,7 +1127,7 @@ TEST_F(RdmaTest, server_miss_after_ack) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -1147,7 +1148,7 @@ TEST_F(RdmaTest, server_miss_after_ack) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
 
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::ESTABLISHED, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ESTABLISHED, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, read(acc_fd, data, 4));
     uint32_t* tmp = (uint32_t*)data;
     ASSERT_EQ(1, butil::NetToHost32(*tmp));
@@ -1178,7 +1179,7 @@ TEST_F(RdmaTest, server_close_after_ack) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -1199,7 +1200,7 @@ TEST_F(RdmaTest, server_close_after_ack) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
 
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::ESTABLISHED, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ESTABLISHED, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(4, read(acc_fd, data, 4));
     uint32_t* tmp = (uint32_t*)data;
     ASSERT_EQ(1, butil::NetToHost32(*tmp));
@@ -1231,7 +1232,7 @@ TEST_F(RdmaTest, server_send_data_on_tcp_after_ack) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::C_HELLO_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::HELLO_WAIT, AdapterTransport::Get(s)->handshake_phase());
 
     butil::fd_guard acc_fd(accept(sockfd, NULL, NULL));
     ASSERT_TRUE(acc_fd >= 0);
@@ -1252,7 +1253,7 @@ TEST_F(RdmaTest, server_send_data_on_tcp_after_ack) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
 
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::ESTABLISHED, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ESTABLISHED, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(acc_fd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     bthread_id_join(cntl.call_id());
 
@@ -1323,9 +1324,9 @@ TEST_F(RdmaTest, v2_server_hello_bytes_baseline) {
     ASSERT_EQ(0, connect(sockfd, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);
     Socket* s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
 
-    // Send a well-formed v2 hello so the server enters S_ACK_WAIT.
+    // Send a well-formed v2 hello so the server enters the common ACK_WAIT.
     rdma::v2_wire::HelloMessage msg{};
     msg.msg_len = rdma::HELLO_V2_MSG_LEN_MIN;
     msg.hello_ver = rdma::HELLO_V2_VERSION;
@@ -1341,7 +1342,7 @@ TEST_F(RdmaTest, v2_server_hello_bytes_baseline) {
     msg.Serialize(data + 4);
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN, write(sockfd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ACK_WAIT, AdapterTransport::Get(s)->handshake_phase());
 
     // Read server's reply hello and assert its byte-level layout.
     uint8_t reply[rdma::HELLO_V2_MSG_LEN_MIN];
@@ -1366,7 +1367,7 @@ TEST_F(RdmaTest, v2_server_hello_bytes_baseline) {
     uint32_t flags = butil::HostToNet32(0);
     ASSERT_EQ(sizeof(flags), write(sockfd, &flags, sizeof(flags)));
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FALLBACK_TCP, AdapterTransport::Get(s)->handshake_phase());
 
     sockfd.reset(-1);
     usleep(100000);
@@ -1388,7 +1389,7 @@ TEST_F(RdmaTest, v2_server_preserves_coalesced_ack_after_extension) {
     usleep(100000);
     Socket* s = GetSocketFromServer(0);
     ASSERT_TRUE(s != NULL);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
 
     // Build a v2 hello with msg_len = 48 (40 base + 8B zero tail).
     rdma::v2_wire::HelloMessage msg{};
@@ -1412,7 +1413,7 @@ TEST_F(RdmaTest, v2_server_preserves_coalesced_ack_after_extension) {
     ASSERT_EQ(sizeof(buf), write(sockfd, buf, sizeof(buf)));
     usleep(100000);
 
-    ASSERT_EQ(RdmaTransport::ESTABLISHED, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ESTABLISHED, AdapterTransport::Get(s)->handshake_phase());
 
     sockfd.reset(-1);
     usleep(100000);
@@ -1434,7 +1435,7 @@ TEST_F(RdmaTest, v2_server_rejects_oversized_msg_len) {
     usleep(100000);
     Socket* s = GetSocketFromServer(0);
     ASSERT_TRUE(s != NULL);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
 
     // Build a v2 hello with msg_len = 4097 (HELLO_V2_MSG_LEN_MAX + 1).
     // We only send the 40B base; the server must reject before reading
@@ -1585,14 +1586,14 @@ TEST_F(RdmaTest, v3_server_hello_bytes_baseline) {
     ASSERT_EQ(0, connect(sockfd, (sockaddr*)&addr, sizeof(sockaddr)));
     usleep(100000);
     Socket* s = GetSocketFromServer(0);
-    ASSERT_EQ(RdmaTransport::UNINIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED, AdapterTransport::Get(s)->handshake_phase());
 
     // Send a valid v3 hello.
     std::string packet = MakeV3Packet(MakeValidV3Hello());
     ASSERT_EQ((ssize_t)packet.size(),
               write(sockfd, packet.data(), packet.size()));
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ACK_WAIT, AdapterTransport::Get(s)->handshake_phase());
 
     // Read server's reply hello: 4B magic + 4B pb_size + body.
     uint8_t reply_magic[4];
@@ -1622,7 +1623,7 @@ TEST_F(RdmaTest, v3_server_hello_bytes_baseline) {
     ASSERT_EQ((ssize_t)sizeof(flags),
               write(sockfd, &flags, sizeof(flags)));
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FALLBACK_TCP, AdapterTransport::Get(s)->handshake_phase());
 
     sockfd.reset(-1);
     usleep(100000);
@@ -1736,8 +1737,8 @@ TEST_F(RdmaTest, v3_server_invalid_sq_size_falls_back) {
     usleep(100000);
 
     // Server validated the hello as invalid -> _rdma_state = RDMA_OFF,
-    // but still proceeds to S_ACK_WAIT (sends its own reply hello).
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT, RdmaTransport::Get(s)->handshake_phase());
+// but still proceeds to the common ACK_WAIT (sends its own reply hello).
+    ASSERT_EQ(handshake::ACK_WAIT, AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF, RdmaTransport::Get(s)->_rdma_state);
 
     // Drain server's reply hello (content not asserted here; covered
@@ -1756,7 +1757,7 @@ TEST_F(RdmaTest, v3_server_invalid_sq_size_falls_back) {
     ASSERT_EQ((ssize_t)sizeof(flags),
               write(sockfd, &flags, sizeof(flags)));
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FALLBACK_TCP, AdapterTransport::Get(s)->handshake_phase());
 
     sockfd.reset(-1);
     usleep(100000);
@@ -1806,7 +1807,7 @@ static void ReadServerV3Reply(int fd, rdma::RdmaHello* reply) {
 }
 
 // A client hello carrying ECE must not break the server handshake: with ECE
-// enabled the server still parses the hello and advances to S_ACK_WAIT.
+// enabled the server still parses the hello and advances to the common ACK_WAIT.
 TEST_F(RdmaTest, v3_server_accepts_client_hello_with_ece) {
     EceFlagGuard ece_flag_guard(true);
     StartServer();
@@ -1828,8 +1829,8 @@ TEST_F(RdmaTest, v3_server_accepts_client_hello_with_ece) {
               write(sockfd, packet.data(), packet.size()));
     usleep(100000);
 
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT,
-              RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ACK_WAIT,
+              AdapterTransport::Get(s)->handshake_phase());
 
     rdma::RdmaHello reply;
     ReadServerV3Reply(sockfd, &reply);
@@ -1838,8 +1839,8 @@ TEST_F(RdmaTest, v3_server_accepts_client_hello_with_ece) {
     uint32_t flags = butil::HostToNet32(0);
     ASSERT_EQ((ssize_t)sizeof(flags), write(sockfd, &flags, sizeof(flags)));
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP,
-              RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FALLBACK_TCP,
+              AdapterTransport::Get(s)->handshake_phase());
 
     sockfd.reset(-1);
     usleep(100000);
@@ -1956,8 +1957,8 @@ TEST_F(RdmaTest, client_alloc_resource_fail_fallback_tcp) {
 
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP,
-              RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FALLBACK_TCP,
+              AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF,
               RdmaTransport::Get(s)->_rdma_state);
     // The socket must not be failed, otherwise it can no longer carry TCP.
@@ -1984,8 +1985,8 @@ TEST_F(RdmaTest, server_alloc_resource_fail_fallback_tcp) {
     usleep(100000);  // wait for server to handle the msg
     Socket* s = GetSocketFromServer(0);
     ASSERT_TRUE(s != NULL);
-    ASSERT_EQ(RdmaTransport::UNINIT,
-              RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::UNINITIALIZED,
+              AdapterTransport::Get(s)->handshake_phase());
 
     // Send a well-formed v2 hello: the negotiation succeeds
     // but the resource allocation does not.
@@ -2005,8 +2006,8 @@ TEST_F(RdmaTest, server_alloc_resource_fail_fallback_tcp) {
     ASSERT_EQ(rdma::HELLO_V2_MSG_LEN_MIN,
               write(sockfd, data, rdma::HELLO_V2_MSG_LEN_MIN));
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::S_ACK_WAIT,
-              RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::ACK_WAIT,
+              AdapterTransport::Get(s)->handshake_phase());
     ASSERT_EQ(RdmaTransport::RDMA_OFF,
               RdmaTransport::Get(s)->_rdma_state);
     ASSERT_FALSE(s->Failed());
@@ -2015,8 +2016,8 @@ TEST_F(RdmaTest, server_alloc_resource_fail_fallback_tcp) {
     uint32_t flags = butil::HostToNet32(0);
     ASSERT_EQ(sizeof(flags), write(sockfd, &flags, sizeof(flags)));
     usleep(100000);
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP,
-              RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FALLBACK_TCP,
+              AdapterTransport::Get(s)->handshake_phase());
     ASSERT_FALSE(s->Failed());
 
     sockfd.reset(-1);
@@ -2048,7 +2049,7 @@ TEST_F(RdmaTest, try_global_disable_rdma) {
     usleep(100000);
     SocketUniquePtr s;
     ASSERT_EQ(0, Socket::Address(cntl._single_server_id, &s));
-    ASSERT_EQ(RdmaTransport::FALLBACK_TCP, RdmaTransport::Get(s)->handshake_phase());
+    ASSERT_EQ(handshake::FALLBACK_TCP, AdapterTransport::Get(s)->handshake_phase());
     bthread_id_join(cntl.call_id());
     ASSERT_EQ(0, cntl.ErrorCode());
 
diff --git a/test/brpc_transport_handshake_unittest.cpp b/test/brpc_transport_handshake_unittest.cpp
index bd904b2067..5aabed5322 100644
--- a/test/brpc_transport_handshake_unittest.cpp
+++ b/test/brpc_transport_handshake_unittest.cpp
@@ -214,19 +214,18 @@ TEST(TransportHandshakeTest, client_runs_codec_and_resource_sequence) {
     std::string calls;
 
     ClientHandshakeCallbacks callbacks{};
-    callbacks.phases = HandshakePhases{1, 2, 3, 4, 5, 6};
     callbacks.codec = MakeTestCodec(&calls);
-    callbacks.prepare_resources = [&]() {
+    callbacks.transport.prepare_resources = [&]() {
         calls += "prepare ";
         return STEP_OK;
     };
-    callbacks.negotiate_resources = [&]() {
+    callbacks.transport.negotiate_resources = [&]() {
         calls += "negotiate ";
         return STEP_OK;
     };
-    callbacks.set_high_speed_active = [&]() { calls += "activate"; };
-    callbacks.set_tcp_active = []() {};
-    callbacks.on_failed = []() {};
+    callbacks.transport.set_high_speed_active = [&]() { calls += "activate"; };
+    callbacks.transport.set_tcp_active = []() {};
+    callbacks.transport.on_failed = []() {};
 
     ASSERT_EQ(STEP_OK, session.RunClient(callbacks));
     ASSERT_EQ("prepare build parse negotiate ack1 activate", calls);
@@ -242,13 +241,12 @@ TEST(TransportHandshakeTest, client_resource_failure_falls_back_before_io) {
     bool tcp_active = false;
 
     ClientHandshakeCallbacks callbacks{};
-    callbacks.phases = HandshakePhases{1, 2, 3, 4, 5, 6};
     callbacks.codec = MakeTestCodec();
-    callbacks.prepare_resources = []() { return STEP_FALLBACK; };
-    callbacks.negotiate_resources = []() { return STEP_ERROR; };
-    callbacks.set_high_speed_active = []() {};
-    callbacks.set_tcp_active = [&]() { tcp_active = true; };
-    callbacks.on_failed = []() {};
+    callbacks.transport.prepare_resources = []() { return STEP_FALLBACK; };
+    callbacks.transport.negotiate_resources = []() { return STEP_ERROR; };
+    callbacks.transport.set_high_speed_active = []() {};
+    callbacks.transport.set_tcp_active = [&]() { tcp_active = true; };
+    callbacks.transport.on_failed = []() {};
 
     ASSERT_EQ(STEP_FALLBACK, session.RunClient(callbacks));
     ASSERT_TRUE(tcp_active);
@@ -266,15 +264,14 @@ TEST(TransportHandshakeTest, server_resumes_at_buffered_ack) {
     std::string calls;
 
     ServerHandshakeCallbacks callbacks{};
-    callbacks.phases = HandshakePhases{11, 12, 13, 14, 15, 16};
     callbacks.fallback_on_not_mine = false;
     callbacks.codecs.push_back(MakeTestCodec(&calls));
     callbacks.input = &input;
-    callbacks.prepare_resources = [&]() {
+    callbacks.transport.prepare_resources = [&]() {
         calls += "prepare ";
         return STEP_OK;
     };
-    callbacks.negotiate_resources = [&]() {
+    callbacks.transport.negotiate_resources = [&]() {
         calls += "negotiate ";
         return STEP_OK;
     };
@@ -282,9 +279,9 @@ TEST(TransportHandshakeTest, server_resumes_at_buffered_ack) {
         calls += "validate ";
         return STEP_OK;
     };
-    callbacks.set_high_speed_active = [&]() { calls += "activate"; };
-    callbacks.set_tcp_active = []() {};
-    callbacks.on_failed = []() {};
+    callbacks.transport.set_high_speed_active = [&]() { calls += "activate"; };
+    callbacks.transport.set_tcp_active = []() {};
+    callbacks.transport.on_failed = []() {};
 
     ASSERT_EQ(STEP_NEED_MORE, session.RunServer(callbacks));
     ASSERT_EQ(16, session.phase());
@@ -308,15 +305,14 @@ TEST(TransportHandshakeTest, server_resource_failure_falls_back_after_ack) {
     bool tcp_active = false;
 
     ServerHandshakeCallbacks callbacks{};
-    callbacks.phases = HandshakePhases{11, 12, 13, 14, 15, 16};
     callbacks.fallback_on_not_mine = false;
     callbacks.codecs.push_back(MakeTestCodec());
     callbacks.input = &input;
-    callbacks.prepare_resources = []() { return STEP_FALLBACK; };
-    callbacks.negotiate_resources = []() { return STEP_ERROR; };
-    callbacks.set_high_speed_active = []() {};
-    callbacks.set_tcp_active = [&]() { tcp_active = true; };
-    callbacks.on_failed = []() {};
+    callbacks.transport.prepare_resources = []() { return STEP_FALLBACK; };
+    callbacks.transport.negotiate_resources = []() { return STEP_ERROR; };
+    callbacks.transport.set_high_speed_active = []() {};
+    callbacks.transport.set_tcp_active = [&]() { tcp_active = true; };
+    callbacks.transport.on_failed = []() {};
 
     ASSERT_EQ(STEP_FALLBACK, session.RunServer(callbacks));
     ASSERT_EQ("HSNO", io.output());
@@ -335,15 +331,14 @@ TEST(TransportHandshakeTest, server_falls_back_without_consuming_other_magic) {
     bool tcp_active = false;
 
     ServerHandshakeCallbacks callbacks{};
-    callbacks.phases = HandshakePhases{11, 12, 13, 14, 15, 16};
     callbacks.fallback_on_not_mine = true;
     callbacks.codecs.push_back(MakeTestCodec());
     callbacks.input = &input;
-    callbacks.prepare_resources = []() { return STEP_ERROR; };
-    callbacks.negotiate_resources = []() { return STEP_ERROR; };
-    callbacks.set_high_speed_active = []() {};
-    callbacks.set_tcp_active = [&]() { tcp_active = true; };
-    callbacks.on_failed = []() {};
+    callbacks.transport.prepare_resources = []() { return STEP_ERROR; };
+    callbacks.transport.negotiate_resources = []() { return STEP_ERROR; };
+    callbacks.transport.set_high_speed_active = []() {};
+    callbacks.transport.set_tcp_active = [&]() { tcp_active = true; };
+    callbacks.transport.on_failed = []() {};
 
     ASSERT_EQ(STEP_FALLBACK, session.RunServer(callbacks));
     ASSERT_TRUE(tcp_active);
@@ -363,15 +358,14 @@ TEST(TransportHandshakeTest, server_enters_hello_phase_after_magic_matches) {
     IOBufHandshakeInput input(&source);
 
     ServerHandshakeCallbacks callbacks{};
-    callbacks.phases = HandshakePhases{11, 12, 13, 14, 15, 16};
     callbacks.fallback_on_not_mine = false;
     callbacks.codecs.push_back(MakeTestCodec());
     callbacks.input = &input;
-    callbacks.prepare_resources = []() { return STEP_OK; };
-    callbacks.negotiate_resources = []() { return STEP_OK; };
-    callbacks.set_high_speed_active = []() {};
-    callbacks.set_tcp_active = []() {};
-    callbacks.on_failed = []() {};
+    callbacks.transport.prepare_resources = []() { return STEP_OK; };
+    callbacks.transport.negotiate_resources = []() { return STEP_OK; };
+    callbacks.transport.set_high_speed_active = []() {};
+    callbacks.transport.set_tcp_active = []() {};
+    callbacks.transport.on_failed = []() {};
 
     source.append("H", 1);
     ASSERT_EQ(STEP_NEED_MORE, session.RunServer(callbacks));

From aebd54e9094a582b1d1f783350cb410547448424 Mon Sep 17 00:00:00 2001
From: Gzure <740684863@qq.com>
Date: Fri, 21 Aug 2026 19:40:17 +0800
Subject: [PATCH 11/11] =?UTF-8?q?handshake=20=E9=80=BB=E8=BE=91=E6=8A=BD?=
 =?UTF-8?q?=E5=8F=96transport=E5=B1=82=EF=BC=8C=E7=94=B1AdapterTransport?=
 =?UTF-8?q?=E7=BB=9F=E4=B8=80=E7=AE=A1=E7=90=86handshake=E5=92=8C=E5=8D=87?=
 =?UTF-8?q?=E7=BA=A7=E5=88=B0rdma/ubshm=E9=80=BB=E8=BE=91?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/cn/urma_proposal.md                      | 527 ------------------
 ...0d20642510e3e3d14a570a041257996772a31.json |   1 -
 ...615a74b896364be016d8a28ec657f714e1422.json |   1 -
 ...ea3f39bb1c3f972074cfdeb983ed964bc1f54.json |   1 -
 ...d4d6ab3654daf64631c4821071a362adf2f1e.json |   1 -
 ...1bdaf944a337cafc10e12152fa2915751f7d0.json |   1 -
 ...705c41b2381b7a5af286fab00d3241d6a5eca.json |   1 -
 ...b8cdaa14683461e3f2562a4ce8dedce8721ed.json |   1 -
 ...7d33a73a6879dca40078e12765880de1061a1.json |   1 -
 ...0956f4dd08aef5a92ffdbffd70a11effd1833.json |   1 -
 ...37defc274c585af039c0e7b995bfe7f0bf804.json |   1 -
 .../urma/graphify-out/cache/stat-index.json   |   1 -
 12 files changed, 538 deletions(-)
 delete mode 100644 docs/cn/urma_proposal.md
 delete mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/01ccfd37e3d64cd110462f1203e0d20642510e3e3d14a570a041257996772a31.json
 delete mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/1df09f4812201fd3151eb13e804615a74b896364be016d8a28ec657f714e1422.json
 delete mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/3dcbdee4a792ca85149ae0eada9ea3f39bb1c3f972074cfdeb983ed964bc1f54.json
 delete mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/5af18e30c1f05aae06e4f45bf09d4d6ab3654daf64631c4821071a362adf2f1e.json
 delete mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/608feeb18131c6633a1d3bae5ce1bdaf944a337cafc10e12152fa2915751f7d0.json
 delete mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/6870b34881c2bda6a7406307467705c41b2381b7a5af286fab00d3241d6a5eca.json
 delete mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/7899e48f9378edf160c448d2d8eb8cdaa14683461e3f2562a4ce8dedce8721ed.json
 delete mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/9ead6eae6b7ea7f4b18e3757e1e7d33a73a6879dca40078e12765880de1061a1.json
 delete mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/bb7775d86173e02925fc786db010956f4dd08aef5a92ffdbffd70a11effd1833.json
 delete mode 100644 src/brpc/urma/graphify-out/cache/ast/v0.9.23/f822344e09f50ff082a2ebbaa0f37defc274c585af039c0e7b995bfe7f0bf804.json
 delete mode 100644 src/brpc/urma/graphify-out/cache/stat-index.json

diff --git a/docs/cn/urma_proposal.md b/docs/cn/urma_proposal.md
deleted file mode 100644
index f41484e105..0000000000
--- a/docs/cn/urma_proposal.md
+++ /dev/null
@@ -1,527 +0,0 @@
-# UrmaTransport 提案：基于 openEuler URMA 的远程内存语义传输层
-
-> 关联讨论：
-> - [#3167 brpc支持传输层多协议改进建议](https://github.com/apache/brpc/issues/3167) —— Socket-Transport 架构改造共识
-> - [#3217 openEuler总线协议 urma 和 obmm 技术路线讨论](https://github.com/apache/brpc/discussions/3217) —— 路线 B（URMA-UrmaTransport）与路线 C（双后端）共识
-> - [#3226 基于UB协议OBMM共享内存Transport方案设计](https://github.com/apache/brpc/issues/3226) —— OBMM/ShmTransport 实现方案
->
-> 本提案对应 #3217 中的**路线 B**，并与 #3226 的 OBMM-ShmTransport 形成**路线 C（双后端协同）**。
-
-## 1. 背景与动机
-
-### 1.1 现有传输层的局限
-
-brpc 当前内置三种传输层（`SOCKET_MODE_TCP` / `SOCKET_MODE_RDMA` / `SOCKET_MODE_UBRING`），均通过 #3167 落地的 `Transport` 抽象接入：
-
-| 传输层 | 访问语义 | 单跳延迟 | 连接模型 | 适用场景 |
-|--------|----------|----------|----------|----------|
-| TCP | Socket API（字节流） | ~50μs | 5-tuple | 广域网/局域网 |
-| RDMA | Verbs API（异步） | ~2-5μs | RC-QP（每连接一个 QP） | 数据中心，`baidu_std` 协议 |
-| UBRing | Load/Store（共享内存） | ~500ns | 共享内存环 | 同机 IPC / UBS-Mem 跨节点 |
-
-三者各有边界，但在以下场景仍存在缺口：
-
-1. **RDMA 的 QP 爆炸**：RC 模型下每条逻辑连接占用一个 QP，千级节点规模下 QP 数量达百万级，耗尽网卡片上 SRAM，触发 QP 状态 Cache Miss，延迟从 ~12μs 跳变至 ~300μs。
-2. **RDMA 的控制面/数据面资源争用**：内存注册/注销与数据面竞争网卡内部资源，高并发下性能抖动。
-3. **RDMA 编程模型笨重**：`准备 WQE → Doorbell → 轮询 CQE` 的异步流程在小包（数百字节）场景下，WQE 构建开销占比可达 17.8%。
-4. **UBRing 的跨节点能力受限**：当前跨节点依赖 UBS-Mem（`ub_shm_type=2`），需要额外 `libubsm_sdk.so`；其 64 字节定长分块（60B payload + 4B header）对大包不友好，单消息上限受 `data_queue_size` 约束（超限返回 `EMSGSIZE`）。
-5. **大包/小包协同缺失**：UBRing 对小包极优（亚微秒、零系统调用），但大包要切分成 ~17k 个 64 字节块逐块拷贝；RDMA 对大包友好（直接 SGE 零拷贝），但小包开销高。目前两者各自独立，无法在一个连接内按包大小自动选择最优路径。
-
-### 1.2 URMA 是什么
-
-[URMA（Unified Remote Memory Access）](https://atomgit.com/openeuler/umdk)是 openEuler 在 UB（Unified Bus）总线上提供的用户态远程内存访问 SDK，核心特性：
-
-- **无连接 UM（Unreliable Datagram）语义**：驱动内置重传/CRC，可靠且免 RC-QP 爆炸——**单 Jetty 可打 N 个远端**，连接数为 O(N) 而非 O(N×线程数)。
-- **统一内存操作语义**：单边（`URMA_OP_SEND`/`URMA_OP_READ`/`URMA_OP_WRITE`）、双边、原子操作通过同一套 `urma_post_send/recv` API 实现，**RoCE v2 / InfiniBand / PCIe P2P 三种底层统一对接**。
-- **URMA-SHM 模式**：远端映射同一物理页，本机与跨机共享内存统一访问，天然适配 `one2all` 场景。
-- **Jetty 流控**：硬件级流控替代 RDMA 的 PFC/ECN，避免拥塞丢包。
-
-性能定位（引用 #3217 实测口径）：
-
-| 技术方案 | 访问方式 | 单跳延迟 | 编程模型 | 缓存一致性 | 适用边界 |
-|----------|----------|----------|----------|------------|----------|
-| RDMA | Verbs API（异步） | ~2-5μs | Read/Write/Send | 无（需软件同步） | 数据中心 |
-| URMA | Segment API（异步） | ~2-5μs | Read/Write | 可选硬件一致性 | 超节点 |
-| OBMM | Load/Store | ~几百ns | 直接内存访问 | 可选 NC 和 CC 两种 | 超节点 |
-
-### 1.3 本提案的目标
-
-**面向超节点（UB 总线互联的 CPU/GPU 集群）场景，新增一个 UrmaTransport，作为 RDMA 在 UB 场景的对等替代与升级**：
-
-1. **性能对标 RDMA**：在 RoCE/IB 底层上达到与现有 `RdmaTransport` 同量级延迟（~2-5μs），并通过 UM 语义消除 QP 爆炸。
-2. **与 UBSHMTransport 大小包协同**：复用 #3226 的 OBMM-ShmTransport 小包极速路径，由 UrmaTransport 承接大包/跨节点高吞吐路径，运行时按包大小与拓扑自动选择（路线 C）。
-3. **复用现有 Transport 框架**：完全沿用 #3167 落地的 `Transport` / `TransportFactory` / `SocketMode` 抽象，不侵入 `Socket`/`InputMessenger`/协议层。
-4. **平滑落地**：参考 `RdmaTransport` 的「compose TcpTransport + tri-state 协商 + TCP fallback」模式，保证未启用/对端不支持时透明回退 TCP。
-
-## 2. 总体架构
-
-### 2.1 在 brpc 中的位置
-
-```mermaid
-flowchart TD
-    subgraph UserAPI["用户接口层"]
-        CS["Channel / Server<br/>ChannelOptions / ServerOptions<br/>socket_mode = SOCKET_MODE_URMA"]
-    end
-    subgraph Factory["TransportFactory (transport_factory.{h,cpp})"]
-        F["if/else-if on SocketMode<br/>TCP → TcpTransport<br/>RDMA → RdmaTransport #if BRPC_WITH_RDMA<br/>UBRING → UBShmTransport #if BRPC_WITH_UBRING<br/>URMA → UrmaTransport #if BRPC_WITH_URMA ★新增"]
-    end
-    subgraph UrmaTransportLayer["UrmaTransport : public Transport (urma_transport.{h,cpp})"]
-        T["std::shared_ptr&lt;TcpTransport&gt; _tcp_transport (fallback)<br/>urma::UrmaEndpoint* _urma_ep<br/>UrmaState _urma_state {ON / OFF / UNKNOWN}"]
-    end
-    subgraph UrmaEndpointLayer["urma::UrmaEndpoint : public SocketUser (urma/urma_endpoint.*)"]
-        E["Jetty / URMA Segment 管理<br/>建链握手状态机（C/S 对称）<br/>数据收发：urma_post_send / urma_post_recv / CQ 轮询<br/>大小包分流：与小包 ShmTransport 协同"]
-    end
-    CS -->|"ContextInitOrDie(mode, ...)<br/>CreateTransport(mode)"| F
-    F --> T
-    T --> E
-```
-
-UrmaTransport 与 `RdmaTransport`、`UBShmTransport` 并列为第四种 `Transport` 实现，对外行为完全一致：用户只需把 `socket_mode` 设为 `SOCKET_MODE_URMA`，其余 brpc API（`Channel`/`Server`/`Controller`/`baidu_std` 协议）零改动。
-
-### 2.2 核心类设计
-
-完全沿用 RDMA/UBShm 已验证的两层结构（Transport + Endpoint），保证代码风格与维护成本对齐：
-
-| 类 | 文件 | 职责 | 参考 |
-|----|------|------|------|
-| `brpc::UrmaTransport` | `src/brpc/urma_transport.{h,cpp}` | `Transport` 子类；持有 `UrmaEndpoint*` + fallback `TcpTransport`；三态 `URMA_ON/OFF/UNKNOWN`；`ContextInitOrDie` 校验协议/SSL | `rdma_transport.{h,cpp}` / `ubshm_transport.{h,cpp}` |
-| `urma::UrmaEndpoint` | `src/brpc/urma/urma_endpoint.{h,cpp}` | 每连接状态机；`SocketUser` 子类；`BAIDU_CACHELINE_ALIGNMENT`；Jetty/Segment 生命周期；CQ 轮询；收发数据路径 | `rdma/rdma_endpoint.{h,cpp}` |
-| `urma::UrmaConnect : public AppConnect` | 同上 | 客户端握手驱动；`StartConnect` 起后台 bthread 跑 `ProcessHandshakeAtClient` | `RdmaConnect` / `UBConnect` |
-| `urma::UrmaHandshake` | `src/brpc/urma/urma_handshake.{h,cpp}` | 握手策略基类 + v2/v3 子类；`ParsedHello` 中间结构；magic 分发 | `rdma/rdma_handshake.{h,cpp}` |
-| `urma::UrmaResource` | 同 endpoint | POD：`urma_jetty*`、`urma_cq*`、comp channel；预连接池 | `RdmaResource` |
-| `urma::BlockPool`（复用） | `src/brpc/rdma/block_pool.{h,cpp}` | 内存注册池；UrmaTransport 复用 RDMA 已有的 `block_pool`（URMA 底层同为 verbs 风格注册） | 现有 |
-| `urma::UrmaHelper` | `src/brpc/urma/urma_helper.{h,cpp}` | 全局初始化；`liburma` dlopen；设备/Jetty 管理 | `rdma/rdma_helper.{h,cpp}` |
-
-**关键设计决策**（与 RDMA 对齐，便于复用与评审）：
-
-1. **Compose TCP，不替换**：`UrmaTransport` 内嵌 `std::shared_ptr<TcpTransport>`，握手未完成/对端不支持/资源不可用时，所有数据路径方法回退到 TCP，保证现有 RPC 语义不破。
-2. **三态协商**：`URMA_UNKNOWN → URMA_ON / URMA_OFF`，数据路径统一判断 `_urma_state != URMA_OFF`，与 RDMA 的 `RDMA_UNKNOWN/ON/OFF` 完全对称。
-3. **Send/Recv + Immediate**：采用 `URMA_OP_SEND_WITH_IMM`（对应 `IBV_WR_SEND_WITH_IMM`），32-bit immediate 携带 recv-WR ack 数，实现 piggyback 流控，避免额外控制报文。不使用单边 RDMA Write/Read 作为主路径，降低收端预注册缓冲的复杂度。
-4. **双窗口 credit 流控**：`_remote_rq_window_size`（对端 recv 容量）+ `_sq_window_size`（本地 SQ 容量），均为 atomic；窗口耗尽返回 EAGAIN，`WaitEpollOut` 阻塞在 `_epollout_butex`。
-5. **复用 `block_pool` + IOBuf allocator 劫持**：URMA 同为 verbs 风格，需要注册内存。直接复用 `src/brpc/rdma/block_pool.{h,cpp}` 与 `rdma_helper.cpp` 中 `butil::iobuf::blockmem_allocate` 的替换逻辑，避免重复造轮子。若内存池后端需区分，通过 `RegisterCallback` 注入 Urma 版本的 `UrmaRegisterMemory`。
-6. **预连接 Jetty 池**：参考 `FLAGS_rdma_prepared_qp_cnt`（默认 1024），在 `GlobalUrmaInitializeOrDie` 时预分配 Jetty+CQ 集合，连接时从池中取，断开后 RESET 回收。
-7. **dlopen `liburma.so`**：参考 `rdma_helper.cpp::ReadRdmaDynamicLib`，运行时 `dlopen` + `dlsym` 解析 `urma_*` 符号，未启用时 `#else` 提供空 stub，保证非 URMA 构建干净。
-
-### 2.3 大小包协同：路线 C 的关键
-
-这是本提案相对于 #3226 OBMM 方案的**核心增量价值**。UBShmTransport（#3226）在 64 字节定长块上对小包极优，但对大包存在 `EMSGSIZE` 上限和 ~17k 块拷贝开销。UrmaTransport 通过 URMA 的 SGE 零拷贝对大包友好。两者协同设计：
-
-```mermaid
-flowchart LR
-    Sock["Socket<br/>(UrmaChannel)"]
-    Sock -->|"小包 &lt; FLAGS_urma_shm_split_threshold<br/>(默认 64KB)"| Small
-    Sock -->|"大包 &gt;= threshold"| Large
-    subgraph Small["小包路径"]
-        S1["走 UBSHMTransport / OBMM 共享内存<br/>Load/Store，~1μs"]
-        S2["适用：特征查询、CTR 分数、<br/>控制信令、ANN 倒排"]
-        S1 --- S2
-    end
-    subgraph Large["大包路径"]
-        L1["走 UrmaTransport<br/>URMA SGE 零拷贝，~2-5μs，无 EMSGSIZE"]
-        L2["适用：Embedding 大向量、<br/>模型参数拉取、特征序列化大包"]
-        L1 --- L2
-    end
-```
-
-**协同实现方式（两选一，倾向方案 A，留待社区讨论）**：
-
-**方案 A：应用层显式选择（推荐先行落地）**
-- 用户在 `ChannelOptions` 中显式为不同服务选择 `socket_mode`：小包服务用 `SOCKET_MODE_UBRING`，大包服务用 `SOCKET_MODE_URMA`。
-- 不引入跨 transport 的连接复用复杂度，符合 brpc「一个 Socket 一种 transport」的既有不变量（见 §3.3 of the RDMA 探索报告：A given Socket is bound to exactly one transport for its lifetime）。
-- 落地快、改动小、可测、可回退。
-
-**方案 B：单连接内按包分流（远期演进，本提案不立即实现）**
-- 新增 `SOCKET_MODE_HYBRID_UB_URMA`，`HybridTransport` 内部同时持有 `UBShmEndpoint` 与 `UrmaEndpoint`。
-- `CutFromIOBufList` 根据 `IOBuf` 总长度路由：小包走 SHM ring，大包走 URMA send。
-- 需要解决：双 Socket 生命周期、双握手、双 CQ 轮询、`_read_buf` 归并解析、`WaitEpollOut` 双路径唤醒。复杂度高，建议方案 A 稳定后再议。
-- 对应 #3217 路线 C「单后端自动切换」。
-
-**本提案先交付方案 A 的 UrmaTransport 主体**，并在文档中明确小包场景建议使用 `SOCKET_MODE_UBRING`（#3226），形成路线 C 的「双后端各司其职」格局。方案 B 作为后续演进方向记录。
-
-## 3. 与 brpc 架构的结合
-
-### 3.1 Transport 接口实现映射
-
-`Transport` 基类（`src/brpc/transport.h`）定义了 10 个纯虚方法。下表给出 `UrmaTransport` 每个方法的实现要点，及其与 `RdmaTransport` 的对应关系：
-
-| `Transport` 虚方法 | `UrmaTransport` 实现 | RDMA 对照 |
-|---|---|---|
-| `Init(socket, options)` | 构造 `UrmaEndpoint(socket)`；创建 fallback `TcpTransport`；若 `options.socket_mode == SOCKET_MODE_URMA` 则设 `_on_edge_trigger = urma::UrmaEndpoint::OnNewDataFromTcp` | `RdmaTransport::Init` |
-| `Release()` | `delete _urma_ep`；释放 Jetty/CQ 资源回预连接池 | `RdmaTransport::Release` |
-| `Reset(expected_nref)` | `UrmaEndpoint::Reset()`：Jetty 置 RESET，CQ drain，状态回 `UNINIT`，窗口计数器归零 | `RdmaEndpoint::Reset` |
-| `Connect()` | 返回 `std::make_shared<urma::UrmaConnect>()`（或用户 `_default_connect`） | `RdmaTransport::Connect` |
-| `CutFromIOBuf(buf)` | `_urma_ep && _urma_state != OFF` → `_urma_ep->CutFromIOBufList({buf},1)`；否则 `_tcp_transport->CutFromIOBuf(buf)` | `RdmaTransport::CutFromIOBuf` |
-| `CutFromIOBufList(bufs,n)` | URMA send 路径：构建 SGE → `urma_post_send` → 窗口扣减；EAGAIN 时返回 -1 | `RdmaEndpoint::CutFromIOBufList` |
-| `WaitEpollOut(butex,pollin,dt)` | `URMA_ON` 且 `!IsWritable()` → `butex_wait(_epollout_butex)`；否则委托 TCP。注意 URMA 同样无法靠 write 探测失败，wait 后需重检 `_socket->Failed()` | `RdmaTransport::WaitEpollOut` |
-| `ProcessEvent(attr)` | 与 TCP 版本一致：把 `OnEdge(socket)` 调度到 bthread | `RdmaTransport::ProcessEvent` |
-| `QueueMessage(msg,n,last)` | 与 TCP 版本一致；尊重 `FLAGS_urma_use_polling`/`FLAGS_urma_disable_bthread` | `RdmaTransport::QueueMessage` |
-| `Debug(os)` | 输出 `UrmaEndpoint::DebugInfo`（状态、Jetty、窗口大小、索引） | `RdmaTransport::Debug` |
-
-数据路径流向（与 RDMA 完全一致，便于评审对照）：
-
-```mermaid
-flowchart TD
-    subgraph Write["写路径"]
-        W1["Socket::DoWrite"] --> W2["UrmaTransport::CutFromIOBufList"]
-        W2 --> W3["UrmaEndpoint::CutFromIOBufList"]
-        W3 --> W4["构建 ibv_sge<br/>(从 IOBuf block refs + block_pool lkey)"]
-        W4 --> W5["urma_post_send(JETTY,<br/>wr=SEND_WITH_IMM, imm=ack_count)"]
-        W5 --> W6{"窗口扣减"}
-        W6 -->|窗口满| W7["EAGAIN -> WaitEpollOut 阻塞"]
-    end
-    subgraph Read["读路径"]
-        R1["URMA CQ comp-channel fd<br/>epoll 触发"] --> R2["Transport::ProcessEvent -><br/>OnEdge -> _on_edge_trigger"]
-        R2 --> R3["UrmaEndpoint::PollCq -> ibv_poll_cq"]
-        R3 --> R4["HandleCompletion"]
-        R4 -->|"SEND"| R5["回收 SQ 窗口<br/>WakeAsEpollOut"]
-        R4 -->|"RECV"| R6["cutn 进 _socket->_read_buf<br/>(zerocopy 阈值)"]
-        R6 --> R7["imm -> 补 _remote_rq_window_size<br/>PostRecv(1) + SendAck(1)"]
-        R7 --> R8["InputMessenger::ProcessNewMessage<br/>(协议解析与 TCP 完全一致)"]
-    end
-```
-
-### 3.2 注册机制（三处改动，完全沿用 RDMA 模板）
-
-参考探索结论：brpc 无动态注册，新 transport 需改三处：
-
-1. **`src/brpc/socket_mode.h`** — 新增枚举：
-```cpp
-enum SocketMode {
-    SOCKET_MODE_TCP   = 0,
-    SOCKET_MODE_RDMA  = 1,
-    SOCKET_MODE_UBRING = 2,
-    SOCKET_MODE_URMA  = 3   // 新增
-};
-```
-
-2. **`src/brpc/transport_factory.cpp`** — 两处 `if/else-if`，`#if BRPC_WITH_URMA` 守卫：
-```cpp
-int TransportFactory::ContextInitOrDie(SocketMode mode, bool serverOrNot, const void* _options) {
-    if (mode == SOCKET_MODE_TCP) { return 0; }
-#if BRPC_WITH_RDMA
-    else if (mode == SOCKET_MODE_RDMA) { return RdmaTransport::ContextInitOrDie(serverOrNot, _options); }
-#endif
-#if BRPC_WITH_UBRING
-    else if (mode == SOCKET_MODE_UBRING) { return UBShmTransport::ContextInitOrDie(serverOrNot, _options); }
-#endif
-#if BRPC_WITH_URMA
-    else if (mode == SOCKET_MODE_URMA) { return UrmaTransport::ContextInitOrDie(serverOrNot, _options); }
-#endif
-    ...
-}
-
-std::unique_ptr<Transport> TransportFactory::CreateTransport(SocketMode mode) {
-    ...
-#if BRPC_WITH_URMA
-    else if (mode == SOCKET_MODE_URMA) {
-        return std::unique_ptr<UrmaTransport>(new UrmaTransport());
-    }
-#endif
-}
-```
-
-3. **`CMakeLists.txt`** — 新增 option 与宏：
-```cmake
-option(WITH_URMA "With URMA (openEuler Unified Remote Memory Access)" OFF)
-if(WITH_URMA)
-    set(BRPC_WITH_URMA 1)
-    # liburma 由 dlopen 加载，无需 link；可选 link libumdk
-    list(APPEND BRPC_PUBLIC_LIBS ${URMA_LIB})
-endif()
-```
-
-所有 `urma*` 源文件统一 `#if BRPC_WITH_URMA ... #else <stub> #endif`，非启用构建零侵入（与 RDMA/UBRing 一致）。
-
-### 3.3 建链握手（双平面：TCP 控制 + URMA 数据）
-
-沿用 RDMA/UBShm 已验证的**「TCP 控制面 + 原生数据面」双平面**模式，避免重新发明轮子：
-
-- **控制面**：复用 brpc 现有的 TCP connect + `AppConnect` 钩子。TCP 连接建立后，`Socket::CheckConnectedAndKeepWrite` 调用 `_app_connect->StartConnect`，在后台 bthread 跑 URMA 握手。
-- **数据面**：握手成功后切换到 URMA Jetty 收发，TCP fd 仅保留用于 epoll 生命周期与 fallback。
-
-**客户端状态机**（`ProcessHandshakeAtClient`，参考 `RdmaEndpoint::ProcessHandshakeAtClient`）：
-
-```mermaid
-stateDiagram-v2
-    [*] --> C_ALLOC_JETTY
-    C_ALLOC_JETTY --> C_HELLO_SEND: AllocateResources()<br/>(从预连接池取 Jetty+CQ，或新建)
-    C_HELLO_SEND --> C_HELLO_WAIT: handshake->SendLocalHello()<br/>(发 "URMA"/"URM3" magic + 本地参数)
-    C_HELLO_WAIT --> C_ACK_SEND: negotiated=true<br/>ApplyRemoteHello + BringUpJetty
-    C_HELLO_WAIT --> C_ACK_SEND: negotiated=false → URMA_OFF
-    C_ACK_SEND --> ESTABLISHED: URMA_ON<br/>(WriteToFd flags_be bit0=URMA_OK)
-    C_ACK_SEND --> FALLBACK_TCP: URMA_OFF
-    ESTABLISHED --> [*]
-    FALLBACK_TCP --> [*]
-```
-
-**服务端状态机**（`ProcessHandshakeAtServer`，由 `_on_edge_trigger = OnNewDataFromTcp` 在首次可读时拉起）：
-
-```mermaid
-stateDiagram-v2
-    [*] --> S_HELLO_WAIT
-    S_HELLO_WAIT --> FALLBACK_TCP: 非 URMA magic<br/>(字节推回 _read_buf, TryReadOnTcp())
-    S_HELLO_WAIT --> S_ALLOC_JETTY: negotiated=true<br/>ApplyRemoteHello
-    S_HELLO_WAIT --> FALLBACK_TCP: negotiated=false -> URMA_OFF
-    S_ALLOC_JETTY --> S_BRINGUP_JETTY: AllocateResources()
-    S_BRINGUP_JETTY --> S_HELLO_SEND: BringUpJetty()
-    S_HELLO_SEND --> S_ACK_WAIT: SendLocalHello()
-    S_ACK_WAIT --> ESTABLISHED: client_ack_ok && !URMA_OFF<br/>(URMA_ON)
-    S_ACK_WAIT --> FAILED: client_ack_ok && URMA_OFF<br/>(SetFailed EPROTO)
-    S_ACK_WAIT --> FALLBACK_TCP: !client_ack_ok<br/>(URMA_OFF)
-    ESTABLISHED --> [*]: TryReadOnTcp()
-    FALLBACK_TCP --> [*]: TryReadOnTcp()
-    FAILED --> [*]
-```
-
-4 字节 ACK `URMA_OK=0x1` 为最终共识位，双端独立决策后确认，不一致即硬错误。与 RDMA 的 `HELLO_ACK_RDMA_OK` 完全对称。
-
-握手 IO 复用 `ReadFromFd`/`WriteToFd`（EAGAIN 感知循环，`_read_butex` 等待 + 50ms `WAIT_TIMEOUT_MS`），直接照搬 `rdma_endpoint.cpp:316-421`。
-
-### 3.4 CQ 作为第二个 Socket
-
-URMA 每连接需要一个额外可 poll 的 fd（CQ comp-channel，或 polling 模式下的 carrier）。参考 `RdmaEndpoint::AllocateResources`（`rdma_endpoint.cpp:1159-1178`）的成熟做法：
-
-- 创建第二个 brpc `Socket`，其 `fd` 为 CQ comp-channel fd，`options.user = this`（即 `UrmaEndpoint`），`options.on_edge_triggered_events = PollCq`。
-- 释放时 `SetFailed()` 该 CQ socket 并清 `_user`，避免 endpoint 被双重释放（参考 `rdma_endpoint.cpp:1370-1380`）。
-- Polling 模式下，参考 `PollerGroup`/`Poller`（每 bthread tag 一组），`FLAGS_urma_poller_num` 个轮询 bthread 循环遍历注册的 CQ socket id。
-
-### 3.5 内存管理
-
-URMA 底层为 verbs 风格，内存需注册。**直接复用 RDMA 的 `block_pool`**（`src/brpc/rdma/block_pool.{h,cpp}`），避免维护两套 slab 池：
-
-- `block_pool` 的 `RegisterCallback` 注入 `UrmaRegisterMemory`（使用 `IBV_ACCESS_LOCAL_WRITE | IBV_ACCESS_RELAXED_ORDERING`，失败回退 `LOCAL_WRITE`，与 `RdmaRegisterMemory` 一致）。
-- `UrmaHelper::GlobalUrmaInitializeOrDieImpl` 中同样劫持 `butil::iobuf::blockmem_allocate` → `BlockAllocate`，使所有 IOBuf block 天然 URMA 可用（参考 `rdma_helper.cpp:584-587`）。
-- 用户态注册内存：复用 `RegisterMemoryForRdma`/`DeregisterMemoryForRdma`/`GetLKey`（在 `block_pool` 的 `g_user_mrs` 表中），或新增 `urma::*` 别名包装以命名清晰。
-
-> **讨论点**：URMA 与 RDMA 是否共享同一个 `block_pool` 实例？若同进程内 RDMA 与 URMA 同时启用（一般不会），需评估设备间 lkey 命名空间。初步建议：单进程二选一，由 `ContextInitOrDie` 校验互斥。
-
-## 4. 关键接口与配置
-
-### 4.1 用户接口
-
-```cpp
-// 客户端
-brpc::ChannelOptions opt;
-opt.socket_mode = brpc::SOCKET_MODE_URMA;   // 选择 UrmaTransport
-opt.protocol = "baidu_std";                  // URMA 仅支持 baidu_std（同 RDMA）
-channel.Init("127.0.0.1:8000", &opt);
-
-// 服务端
-brpc::ServerOptions sopt;
-sopt.socket_mode = brpc::SOCKET_MODE_URMA;
-server.Start(port, &sopt);
-```
-
-`OptionsAvailableForUrma` / `OptionsAvailableOverUrma` 校验：拒绝 SSL、RTMP、NSHEAD、MONGO；仅允许 `baidu_std` 协议（与 `SupportedByRdma` 对齐）。
-
-### 4.2 gflags（对照 RDMA 命名，`urma_*` 前缀）
-
-| Flag | 默认 | 文件 | 用途 |
-|------|------|------|------|
-| `--urma_max_sge` | 0 | `urma_helper.cpp` | 每 WR SGE 上限；0=设备上限 |
-| `--urma_device` | "" | `urma_helper.cpp` | URMA 设备名；空=首个活跃 |
-| `--urma_sq_size` | 128 | `urma_endpoint.cpp` | 每连接 SQ 深度（[16,4096]） |
-| `--urma_rq_size` | 128 | `urma_endpoint.cpp` | 每连接 RQ 深度 |
-| `--urma_prepared_jetty_cnt` | 8 | `urma_endpoint.cpp` | 预连接 Jetty 池大小 |
-| `--urma_cqe_poll_once` | 32 | `urma_endpoint.cpp` | 每次 `ibv_poll_cq` 上限 |
-| `--urma_recv_zerocopy` | true | `urma_endpoint.cpp` | 接收零拷贝开关 |
-| `--urma_zerocopy_min_size` | 512 | `urma_endpoint.cpp` | 零拷贝阈值（小于则拷贝） |
-| `--urma_use_polling` | false | `urma_endpoint.cpp` | 轮询 vs 事件模式 |
-| `--urma_poller_num` | 1 | `urma_endpoint.cpp` | 每 bthread tag 轮询器数 |
-| `--urma_poller_yield` | false | `urma_endpoint.cpp` | 轮询循环 `bthread_yield` |
-| `--urma_disable_bthread` | false | `urma_endpoint.cpp` | 内联处理消息（不走 bthread） |
-| `--urma_trace_verbose` | false | `urma_endpoint.cpp` | 握手详细日志 |
-| `--urma_client_handshake_version` | 2 | `urma_handshake.cpp` | 握手版本（2=binary,3=protobuf） |
-| `--urma_memory_pool_initial_size_mb` | 1024 | `block_pool.cpp` | 内存池初始大小（复用） |
-| `--urma_memory_pool_max_regions` | 3 | `block_pool.cpp` | 内存池区域上限（硬上限16） |
-
-### 4.3 与 UBSHMTransport 的协同约定
-
-| 场景 | 建议 `socket_mode` | 理由 |
-|------|---------------------|------|
-| 同机 IPC（同主机进程间） | `SOCKET_MODE_UBRING` | Load/Store 亚微秒，零系统调用 |
-| 超节点跨机小包（<64KB，特征/分数/控制） | `SOCKET_MODE_UBRING`（`ub_shm_type=2` UBS-Mem）或 `SOCKET_MODE_URMA` | 两者均优；UBRing 更低延迟 |
-| 超节点跨机大包（>=64KB，Embedding/参数） | `SOCKET_MODE_URMA` | SGE 零拷贝，无 `EMSGSIZE` |
-| 传统 RoCE/IB 数据中心 | `SOCKET_MODE_URMA` 或 `SOCKET_MODE_RDMA` | URMA 统一语义，无 QP 爆炸 |
-
-`--urma_shm_split_threshold`（默认 64KB）为方案 B（hybrid）预留 flag，方案 A 阶段仅作文档阈值参考。
-
-## 5. 文件清单与改动范围
-
-### 5.1 新增文件
-
-```
-src/brpc/
-├── urma_transport.h          # UrmaTransport : public Transport
-├── urma_transport.cpp
-├── urma/
-│   ├── urma_endpoint.h       # UrmaEndpoint : public SocketUser, UrmaConnect, UrmaResource
-│   ├── urma_endpoint.cpp
-│   ├── urma_helper.h         # 全局初始化, liburma dlopen, 设备管理
-│   ├── urma_helper.cpp
-│   ├── urma_handshake.h      # 握手策略基类 + v2/v3 子类
-│   ├── urma_handshake.cpp
-│   ├── urma_handshake.proto  # v3 protobuf 握手（参考 rdma_handshake.proto）
-│   └── mock_urma.cpp          # URMA 链接时 mock（无 liburma 时编译，供 CI 测试）
-# URMA SDK 头文件（urma_api.h/urma_types.h/urma_opcode.h）通过系统安装提供，
-# CMake find_path(URMA_INCLUDE_PATH NAMES urma_api.h) 查找，不 vendored 到代码目录
-docs/
-├── cn/urma.md
-└── en/urma.md
-example/
-└── urma_performance/
-    ├── client.cpp
-    └── server.cpp
-test/
-└── brpc_urma_unittest.cpp
-```
-
-### 5.2 修改文件
-
-| 文件 | 改动 |
-|------|------|
-| `src/brpc/socket_mode.h` | 新增 `SOCKET_MODE_URMA = 3` |
-| `src/brpc/transport_factory.{h,cpp}` | 两个 `if/else-if` 分支，`#if BRPC_WITH_URMA` 守卫 |
-| `src/brpc/channel.h` | `ChannelOptions::socket_mode` 注释补充 URMA |
-| `src/brpc/server.h` | `ServerOptions::socket_mode` 注释补充 URMA |
-| `src/brpc/input_messenger.h` | `friend class urma::UrmaEndpoint;` |
-| `CMakeLists.txt` | `option(WITH_URMA ...)` + `BRPC_WITH_URMA` 宏 + 源文件列表 |
-
-### 5.3 复用文件（不改或最小改）
-
-- `src/brpc/rdma/block_pool.{h,cpp}` — 内存注册池（`RegisterCallback` 注入 Urma 版本）
-- `src/brpc/rdma/rdma_helper.cpp` — `blockmem_allocate` 劫持逻辑（提取为公共或 Urma 复制一份）
-- `src/brpc/tcp_transport.{h,cpp}` — fallback 依赖
-
-## 6. 落地计划
-
-### Phase 1：框架与最小可用（本提案目标）
-1. `SocketMode` + `TransportFactory` 注册通路。
-2. `UrmaTransport` + `UrmaEndpoint` 骨架：三态、TCP fallback、握手状态机（v2 binary）。
-3. 数据路径：`CutFromIOBufList` 走 `urma_post_send(SEND_WITH_IMM)`，`PollCq` + `HandleCompletion` 走 recv。
-4. 复用 `block_pool`。
-5. `example/urma_performance` 可跑通 `baidu_std` echo。
-6. 单测 `brpc_urma_unittest.cpp`（参考 `brpc_rdma_unittest.cpp` 与新写的 `brpc_ubring_unittest.cpp`）。
-
-### Phase 2：性能与协同
-1. 握手 v3（protobuf `UrmaHello`），前向兼容。
-2. Polling 模式 + `PollerGroup` per-tag。
-3. Unsignaled/solicited 完成抑制（降低 CPU）。
-4. 与 UBSHMTransport 的大小包协同文档与示例（方案 A）。
-
-### Phase 3：演进（留待社区讨论）
-1. 方案 B：`SOCKET_MODE_HYBRID_UB_URMA` 单连接按包分流。
-2. URMA-SHM 模式接入，与本机 UBRing 统一。
-3. GPU memory 直接注册（`urma_register_memory` over HBM），对接 GPUDirect 类语义。
-
-## 7. 风险与开放问题
-
-1. **硬件/驱动依赖**：URMA 需要 openEuler UB 驱动 + `liburma`。非 UB 平台只能 fallback TCP。是否接受 ko 依赖已在 #3217 征询，本提案沿用其结论。**CI 无 URMA 硬件时的可测试性由 §7.1 的 mock 保证**。
-2. **`block_pool` 复用边界**：URMA 与 RDMA 共享内存池的设备命名空间问题，倾向 `ContextInitOrDie` 互斥校验，需评审确认。
-3. **URMA API 成熟度**：`urma_post_send`/`urma_post_recv` 与 verbs 的差异需在 `UrmaEndpoint` 适配层抹平（如 `ibv_sge` 是否复用、imm_data 位宽）。Phase 1 需先对齐 SDK 头文件。
-4. **大小包协同方案选择**：方案 A（显式）vs 方案 B（自动分流）的取舍，请社区给出倾向。本提案默认先 A 后 B。
-5. **`baidu_std` 协议限制**：与 RDMA 一致，暂不支持其他协议。若社区有 URMA over HTTP 等需求，后续议。
-6. **跨平台**：URMA 当前为 Linux/openEuler 专有。macOS/Windows 提供 stub（同 RDMA/UBRing 的 `#else` 处理）。
-
-### 7.1 URMA Mock：无硬件环境下的 CI 可测试性
-
-**问题**：brpc 的 CI 运行在普通 Linux 容器中，没有 URMA 硬件/`liburma`。若 `WITH_URMA=ON` 时找不到 `liburma` 就 `FATAL_ERROR`，CI 无法构建和测试 UrmaTransport，回归风险高。
-
-**方案**：在 brpc 中内置一个 **链接时替换（link-time substitution）** 的 URMA mock。
-
-```mermaid
-flowchart TD
-    Build["cmake -DWITH_URMA=ON"]
-    Build --> Find{"find_library(URMA_LIB NAMES urma)"}
-    Find -->|"找到 liburma.so"| Real["编译 UrmaTransport<br/>链接 liburma<br/>URMA_USE_MOCK=0"]
-    Find -->|"未找到"| Mock["编译 UrmaTransport + mock_urma.cpp<br/>不链接 liburma<br/>URMA_USE_MOCK=1"]
-    Real --> Test1["硬件环境测试<br/>(真实 URMA)"]
-    Mock --> Test2["CI 无硬件环境测试<br/>(mock 完成路径)"]
-```
-
-**Mock 设计**（`src/brpc/urma/mock_urma.cpp`，Mooncake 同款模式）：
-
-| 设计点 | 实现 |
-|--------|------|
-| 替换方式 | **链接时**：mock 定义与 `liburma.so` 完全同名的 `urma_*` 自由函数符号，链接器按链接顺序选择 mock |
-| 对象存储 | 匿名命名空间内 `std::map<opaque_ptr*, int>` 注册表，按对象类型分表（`context_map`/`jfc_state_map`/`jfr_map`/`seg_map`/`jetty_map`/`target_jetty_map`） |
-| 成员校验 | 每个 `delete_*` 检查 map 成员资格，误用返回 `URMA_EINVAL` 而非崩溃 |
-| 完成路径 | 每个 posted send/recv WR 的 `user_ctx` 推入所属 JFC 的 FIFO，下次 `urma_poll_jfc` 返回 `URMA_CR_SUCCESS` |
-| 数据搬运 | **不搬运 payload 字节**--mock 是控制面替身，仅驱动握手/状态机；CI 数据路径测试不校验 payload 内容 |
-| 设备名契约 | `device->name == "mock_urma_device"`，测试用 `--urma_device=mock_urma_device` 匹配 |
-
-**Mock 覆盖的 `urma_*` 符号**（brpc transport 实际调用的全集）：
-
-```
-urma_init / urma_uninit
-urma_get_device_list / urma_free_device_list / urma_get_device_by_name
-urma_query_device / urma_get_eid_list / urma_free_eid_list
-urma_create_context / urma_delete_context
-urma_create_jfce / urma_delete_jfce
-urma_create_jfc / urma_delete_jfc
-urma_create_jfr / urma_delete_jfr
-urma_register_seg / urma_unregister_seg
-urma_import_seg / urma_unimport_seg
-urma_create_jetty / urma_delete_jetty
-urma_import_jetty / urma_unimport_jetty
-urma_bind_jetty / urma_unbind_jetty / urma_modify_jetty
-urma_post_jetty_send_wr       (send 路径)
-urma_post_jfr_wr              (recv 路径，Mooncake mock 未含，brpc 新增)
-urma_poll_jfc                  (完成轮询)
-urma_get_async_event / urma_ack_async_event
-```
-
-> **与 Mooncake mock 的差异**：Mooncake 的 transport 是单边 write/read（仅 JFS），mock 不含 `urma_post_jfr_wr`。brpc 的 `UrmaEndpoint` 是双边 send/recv，recv 路径走 `urma_post_jfr_wr`，故 brpc mock 新增该函数--将 recv WR 的 `user_ctx` 推入 JFC 的 `pending_recv` 队列，`urma_poll_jfc` 先排空 send 完成再排空 recv 完成（`cr.flag.bs.s_r` 区分）。
-
-**CMake 集成**（`CMakeLists.txt`）：
-
-```cmake
-if(WITH_URMA)
-    find_library(URMA_LIB NAMES urma)
-    if(URMA_LIB)
-        message(STATUS "Found liburma: ${URMA_LIB}")
-        set(URMA_USE_MOCK 0)
-    else()
-        message(WARNING "liburma not found; building UrmaTransport with the bundled mock.")
-        set(URMA_USE_MOCK 1)
-    endif()
-endif()
-# ... 源文件收集 ...
-if(WITH_URMA AND NOT URMA_USE_MOCK)
-    list(REMOVE_ITEM BRPC_SOURCES
-         "${PROJECT_SOURCE_DIR}/src/brpc/urma/mock_urma.cpp")
-endif()
-# ... 链接 ...
-if(WITH_URMA)
-    if(NOT URMA_USE_MOCK)
-        list(APPEND DYNAMIC_LIB ${URMA_LIB})
-    endif()
-endif()
-```
-
-**Mock 自身守卫**：`mock_urma.cpp` 包裹在 `#if BRPC_WITH_URMA ... #endif` 中，`WITH_URMA=OFF` 时不编译（与其它 URMA 源一致）。
-
-**CI 保证**：
-
-- `WITH_URMA=OFF`：所有 URMA 源编译为空 stub，mock 不参与编译，brpc 主库与现有行为一致。
-- `WITH_URMA=ON` + 无 `liburma`（CI 默认）：mock 编译进 brpc，`brpc_urma_unittest` 链接 mock，跑通握手序列化/状态机/fallback 等纯逻辑测试。
-- `WITH_URMA=ON` + 有 `liburma`（硬件环境）：mock 从源列表移除，链接真实 `liburma`，跑通真实 URMA 数据路径。
-
-## 8. 与既有提案的关系
-
-| 提案 | 关系 |
-|------|------|
-| #3167 | 本提案完全基于其落地的 `Transport` 抽象，不再讨论架构改造 |
-| #3217 路线 B | 本提案即路线 B 的具体设计 |
-| #3217 路线 C | 本提案 §2.3 给出方案 A（先行）+ 方案 B（演进），与 #3226 OBMM 形成 C |
-| #3226 | OBMM-ShmTransport 为小包路径，本提案 UrmaTransport 为大包/跨节点路径，互补 |
-
-## 9. 致谢
-
-感谢 @chenBright @wwbmmm @yanglimingcn @ivanallen @dwh110 在 #3167 / #3217 / #3226 中的深入讨论，本提案在架构取舍上大量吸纳了这些讨论结论（尤其是 wwbmmm 关于「Transport 持有协议私有成员、Socket 只持 `_transport` 指针」的解耦思路，已成为现有 `Transport` 接口的设计基线）。
-
-欢迎各位继续评审，特别是：
-- 方案 A vs 方案 B 的倾向
-- `block_pool` 复用 vs 独立
-- URMA SDK API 与 verbs 的差异适配
-- Phase 划分与落地节奏
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/01ccfd37e3d64cd110462f1203e0d20642510e3e3d14a570a041257996772a31.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/01ccfd37e3d64cd110462f1203e0d20642510e3e3d14a570a041257996772a31.json
deleted file mode 100644
index dc93d7be43..0000000000
--- a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/01ccfd37e3d64cd110462f1203e0d20642510e3e3d14a570a041257996772a31.json
+++ /dev/null
@@ -1 +0,0 @@
-{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_opcode_h", "label": "urma_opcode.h", "file_type": "code", "source_file": "sdk/urma/urma_opcode.h", "source_location": "L1"}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_opcode_h", "target": "errno", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_opcode.h", "source_location": "L14", "weight": 1.0}], "raw_calls": []}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/1df09f4812201fd3151eb13e804615a74b896364be016d8a28ec657f714e1422.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/1df09f4812201fd3151eb13e804615a74b896364be016d8a28ec657f714e1422.json
deleted file mode 100644
index ebff288857..0000000000
--- a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/1df09f4812201fd3151eb13e804615a74b896364be016d8a28ec657f714e1422.json
+++ /dev/null
@@ -1 +0,0 @@
-{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_h", "label": "urma_helper.h", "file_type": "code", "source_file": "urma_helper.h", "source_location": "L1"}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_h", "target": "cstddef", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.h", "source_location": "L21", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_h", "target": "cstdint", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.h", "source_location": "L22", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_h", "target": "functional", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.h", "source_location": "L23", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_h", "target": "string", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.h", "source_location": "L24", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_h", "target": "types", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.h", "source_location": "L26", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_h", "target": "atomicops", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.h", "source_location": "L27", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_h", "target": "urma_api", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.h", "source_location": "L31", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_h", "target": "urma_types", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.h", "source_location": "L32", "weight": 1.0}], "raw_calls": []}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/3dcbdee4a792ca85149ae0eada9ea3f39bb1c3f972074cfdeb983ed964bc1f54.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/3dcbdee4a792ca85149ae0eada9ea3f39bb1c3f972074cfdeb983ed964bc1f54.json
deleted file mode 100644
index 4bfad372ec..0000000000
--- a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/3dcbdee4a792ca85149ae0eada9ea3f39bb1c3f972074cfdeb983ed964bc1f54.json
+++ /dev/null
@@ -1 +0,0 @@
-{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "label": "urma_handshake.cpp", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L1"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "label": "HelloMessage::Serialize()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L72", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "label": "HelloMessage::Deserialize()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L91", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_validhello", "label": "ValidHello()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L127", "_callable": true}, {"id": "parsedhello", "label": "ParsedHello", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_handshake.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "label": "ReadBodyAndNegotiate()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L141", "_callable": true}, {"id": "urmaendpoint", "label": "UrmaEndpoint", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_handshake.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_drainbytes", "label": "DrainBytes()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L173", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_sendlocalhello", "label": "UrmaHandshakeClientV2::SendLocalHello()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L187", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_receiveandparseremotehello", "label": "UrmaHandshakeClientV2::ReceiveAndParseRemoteHello()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L196", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_receiveandparseremotehello", "label": "UrmaHandshakeServerV2::ReceiveAndParseRemoteHello()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L210", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "label": "UrmaHandshakeServerV2::SendLocalHello()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L215", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_sendlocalhello", "label": "UrmaHandshakeClientV3::SendLocalHello()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L240", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_receiveandparseremotehello", "label": "UrmaHandshakeClientV3::ReceiveAndParseRemoteHello()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L246", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_receiveandparseremotehello", "label": "UrmaHandshakeServerV3::ReceiveAndParseRemoteHello()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L258", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_sendlocalhello", "label": "UrmaHandshakeServerV3::SendLocalHello()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L263", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createclienthandshake", "label": "CreateClientHandshake()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L274", "_callable": true}, {"id": "urmahandshake", "label": "UrmaHandshake", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_handshake.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createserverhandshakebymagic", "label": "CreateServerHandshakeByMagic()", "file_type": "code", "source_file": "urma_handshake.cpp", "source_location": "L282", "_callable": true}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "urma_handshake", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L18", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "algorithm", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L22", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "cstring", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L23", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "limits", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L24", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "gflags", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L26", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "atomicops", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L28", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "iobuf", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L29", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "logging", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L30", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "sys_byteorder", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L31", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "socket", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L33", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "urma_endpoint", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L34", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "urma_helper", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L35", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "urma_handshake", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L36", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "urma_transport", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L37", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L72", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L91", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_validhello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L127", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_validhello", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L127", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L141", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "target": "urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L141", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L141", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_drainbytes", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L173", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_drainbytes", "target": "urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L173", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_sendlocalhello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L187", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_receiveandparseremotehello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L196", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_receiveandparseremotehello", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L196", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_receiveandparseremotehello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L210", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_receiveandparseremotehello", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L210", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L215", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_sendlocalhello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L240", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_receiveandparseremotehello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L246", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_receiveandparseremotehello", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L246", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_receiveandparseremotehello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L258", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_receiveandparseremotehello", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L258", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_sendlocalhello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L263", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createclienthandshake", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L274", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createclienthandshake", "target": "urmahandshake", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L274", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createclienthandshake", "target": "urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L274", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createserverhandshakebymagic", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L282", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createserverhandshakebymagic", "target": "urmahandshake", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L282", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createserverhandshakebymagic", "target": "urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L282", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_validhello", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L163", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_drainbytes", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L166", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_receiveandparseremotehello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L207", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_receiveandparseremotehello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_handshake.cpp", "source_location": "L212", "weight": 1.0}], "raw_calls": [{"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet16", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L74", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet16", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L75", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet16", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L76", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L77", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L78", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L79", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "memcpy", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L80", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L81", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "memset", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L83", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "memcpy", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L84", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L85", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet64", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L86", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet64", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L87", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "callee": "HostToNet32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L88", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost16", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L93", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost16", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L94", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost16", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L95", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L96", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L97", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L98", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "memcpy", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L99", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L100", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "memcpy", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L103", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L104", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost64", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L105", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost64", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L106", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "callee": "NetToHost32", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L107", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "callee": "ReadFromFd", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L144", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "callee": "Deserialize", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L146", "receiver": "m", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "callee": "memcpy", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L155", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_readbodyandnegotiate", "callee": "memcpy", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L158", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_drainbytes", "callee": "ReadFromFd", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L177", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_sendlocalhello", "callee": "FillLocalHelloV2", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L189", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_sendlocalhello", "callee": "memcpy", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L191", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_sendlocalhello", "callee": "Serialize", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L192", "receiver": "m", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_sendlocalhello", "callee": "WriteToFd", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L193", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_receiveandparseremotehello", "callee": "ReadFromFd", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L200", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_receiveandparseremotehello", "callee": "memcmp", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L201", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_receiveandparseremotehello", "callee": "PushBackToReadBuf", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L204", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "callee": "FillLocalHelloV2", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L217", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "callee": "get", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L218", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "callee": "load", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L219", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "callee": "memcpy", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L229", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "callee": "Serialize", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L230", "receiver": "m", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "callee": "WriteToFd", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L231", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_sendlocalhello", "callee": "FillLocalHelloV3", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L242", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_sendlocalhello", "callee": "WriteHelloV3", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L243", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_receiveandparseremotehello", "callee": "ReadFromFd", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L250", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_receiveandparseremotehello", "callee": "memcmp", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L251", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_receiveandparseremotehello", "callee": "PushBackToReadBuf", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L252", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_receiveandparseremotehello", "callee": "ReadAndParseHelloV3", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L255", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_receiveandparseremotehello", "callee": "ReadAndParseHelloV3", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L260", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_sendlocalhello", "callee": "FillLocalHelloV3", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L265", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_sendlocalhello", "callee": "WriteHelloV3", "is_member_call": true, "source_file": "urma_handshake.cpp", "source_location": "L267", "receiver": "_ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createserverhandshakebymagic", "callee": "memcmp", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L284", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_createserverhandshakebymagic", "callee": "memcmp", "is_member_call": false, "source_file": "urma_handshake.cpp", "source_location": "L287", "receiver": null, "lang": "cpp"}], "cpp_type_table": {"path": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_handshake.cpp", "table": {"p": "ParsedHello", "m": "HelloMessage", "msg": "UrmaHello"}}}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/5af18e30c1f05aae06e4f45bf09d4d6ab3654daf64631c4821071a362adf2f1e.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/5af18e30c1f05aae06e4f45bf09d4d6ab3654daf64631c4821071a362adf2f1e.json
deleted file mode 100644
index 9e5c46ae91..0000000000
--- a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/5af18e30c1f05aae06e4f45bf09d4d6ab3654daf64631c4821071a362adf2f1e.json
+++ /dev/null
@@ -1 +0,0 @@
-{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "label": "urma_helper.cpp", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L1"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg", "label": "UserSeg", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L139", "_callable": true}, {"id": "urma_target_seg_t", "label": "urma_target_seg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg_tseg", "label": "tseg", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L140"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg_base", "label": "base", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L141"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg_len", "label": "len", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L142"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pagesize", "label": "PageSize()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L155", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_alignup", "label": "AlignUp()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L160", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "label": "BufferPool", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L174", "_callable": true}, {"id": "mutex", "label": "Mutex", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_mutexes", "label": "mutexes", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L175"}, {"id": "vector", "label": "vector", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_free_lists", "label": "free_lists", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L176"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_in_use", "label": "in_use", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L177"}, {"id": "atomic", "label": "atomic", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_outstanding", "label": "outstanding", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L178"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_buffer_count", "label": ".buffer_count()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L180", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_shardfor", "label": "ShardFor()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L186", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_preferredshard", "label": "PreferredShard()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L193", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "label": "PoolAllocate()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L200", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "label": "PoolDeallocate()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L227", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "label": "InitPool()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L259", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_getpoolsegfor", "label": "GetPoolSegFor()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L313", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "label": "GlobalRelease()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L324", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "label": "GlobalUrmaInitializeImpl()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L372", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "label": "GlobalUrmaInitializeOrDie()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L521", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_isurmaavailable", "label": "IsUrmaAvailable()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L540", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globaldisableurma", "label": "GlobalDisableUrma()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L544", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_supportedbyurma", "label": "SupportedByUrma()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L548", "_callable": true}, {"id": "string", "label": "string", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_geturmacontext", "label": "GetUrmaContext()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L552", "_callable": true}, {"id": "urma_context_t", "label": "urma_context_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_geturmamaxsge", "label": "GetUrmaMaxSge()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L553", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_geturmarecvblocksize", "label": "GetUrmaRecvBlockSize()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L554", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "label": "InitPollingModeWithTag()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L560", "_callable": true}, {"id": "bthread_tag_t", "label": "bthread_tag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp"}, {"id": "function", "label": "function", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_releasepollingmodewithtag", "label": "ReleasePollingModeWithTag()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L570", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_registermemoryforurma", "label": "RegisterMemoryForUrma()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L578", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_deregistermemoryforurma", "label": "DeregisterMemoryForUrma()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L613", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_getseghandle", "label": "GetSegHandle()", "file_type": "code", "source_file": "urma_helper.cpp", "source_location": "L622", "_callable": true}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "urma_helper", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L18", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "errno", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L22", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "pthread", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L23", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "stdlib", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L24", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "string", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L25", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "mman", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L26", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "unistd", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L27", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "atomic", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L29", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "new", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L30", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "utility", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L31", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "vector", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L32", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "gflags", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L34", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "atomicops", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L36", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "flat_map", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L37", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "iobuf", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L38", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "logging", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L39", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "macros", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L40", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "scoped_lock", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L41", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "lock", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L42", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "urma_api", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L44", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "urma_types", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L45", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "urma_endpoint", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L46", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L139", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L140", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg_tseg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L140", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg_base", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L141", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_userseg_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L142", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pagesize", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L155", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_alignup", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L160", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L174", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "target": "mutex", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L175", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_mutexes", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L175", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "target": "vector", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L176", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_free_lists", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L176", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "target": "vector", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L177", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_in_use", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L177", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "target": "atomic", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L178", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_outstanding", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L178", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_buffer_count", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L180", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_shardfor", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L186", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_preferredshard", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L193", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L200", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L227", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L259", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_getpoolsegfor", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L313", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_getpoolsegfor", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L313", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L324", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L372", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L521", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_isurmaavailable", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L540", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globaldisableurma", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L544", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_supportedbyurma", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L548", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_supportedbyurma", "target": "string", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L548", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_geturmacontext", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L552", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_geturmacontext", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L552", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_geturmamaxsge", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L553", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_geturmarecvblocksize", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L554", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L560", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "target": "bthread_tag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L560", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "target": "function", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L560", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "target": "function", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L560", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "target": "function", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L560", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_releasepollingmodewithtag", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L570", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_releasepollingmodewithtag", "target": "bthread_tag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L570", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_registermemoryforurma", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L578", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_deregistermemoryforurma", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L613", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_getseghandle", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L622", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "cstdlib", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L653", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "logging", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L655", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L660", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_preferredshard", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L209", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_shardfor", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L242", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_buffer_count", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L261", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pagesize", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L264", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_alignup", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L265", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "target": "string", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L414", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L485", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_buffer_count", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L514", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L527", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_helper.cpp", "source_location": "L529", "weight": 1.0}], "raw_calls": [{"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pagesize", "callee": "sysconf", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L156", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_bufferpool_buffer_count", "callee": "size", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L181", "receiver": "in_use", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_preferredshard", "callee": "pthread_self", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L196", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "BAIDU_UNLIKELY", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L201", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "g_mem_alloc_orig", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L202", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "malloc", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L202", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "g_mem_alloc_orig", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L207", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "malloc", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L207", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "BAIDU_SCOPED_LOCK", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L212", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "empty", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L214", "receiver": "fl", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "back", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L215", "receiver": "fl", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "pop_back", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L216", "receiver": "fl", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "size", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L219", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "fetch_add", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L220", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L223", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "g_mem_alloc_orig", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L224", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_poolallocate", "callee": "malloc", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L224", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "BAIDU_UNLIKELY", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L228", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "g_mem_dealloc_orig", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L229", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "free", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L230", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "g_mem_dealloc_orig", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L238", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "free", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L239", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "BAIDU_SCOPED_LOCK", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L243", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "size", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L245", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L247", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "push_back", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L252", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "load", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L253", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_pooldeallocate", "callee": "fetch_sub", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L254", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "callee": "mmap", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L267", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "callee": "PLOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L270", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "callee": "urma_register_seg", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L290", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "callee": "PLOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L292", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "callee": "munmap", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L293", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "callee": "assign", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L297", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "callee": "push_back", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L300", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpool", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L303", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "callee": "store", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L325", "receiver": "g_urma_available", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "callee": "SetDefaultBlockSize", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L335", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "callee": "GlobalRelease", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L338", "receiver": "UrmaEndpoint", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "callee": "urma_unregister_seg", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L340", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "callee": "munmap", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L344", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "callee": "urma_delete_context", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L355", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "callee": "urma_uninit", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L359", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalrelease", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L361", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "BAIDU_UNLIKELY", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L373", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "store", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L374", "receiver": "g_urma_available", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L381", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_init", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L387", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L390", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L398", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_get_device_list", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L405", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L407", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_free_device_list", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L408", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "empty", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L413", "receiver": "FLAGS_urma_device", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L420", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_free_device_list", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L421", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_query_device", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L427", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L428", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_free_device_list", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L429", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_get_eid_list", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L434", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L436", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_free_eid_list", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L437", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_free_device_list", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L438", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_create_context", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L442", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_free_eid_list", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L443", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "urma_free_device_list", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L444", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L447", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L457", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "init", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L471", "receiver": "g_user_segs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L472", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "assign", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L481", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "reserve", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L483", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L486", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "GetDefaultBlockSize", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L495", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "SetDefaultBlockSize", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L498", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "GlobalInitialize", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L500", "receiver": "UrmaEndpoint", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L501", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "store", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L505", "receiver": "g_urma_available", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeimpl", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L511", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "callee": "load", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L523", "receiver": "g_init_once", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "callee": "compare_exchange_strong", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L524", "receiver": "g_init_once", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "callee": "BAIDU_SCOPED_LOCK", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L526", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L528", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "callee": "store", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L531", "receiver": "g_init_once", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "callee": "load", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L534", "receiver": "g_init_once", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_isurmaavailable", "callee": "load", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L541", "receiver": "g_urma_available", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globaldisableurma", "callee": "store", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L545", "receiver": "g_urma_available", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "callee": "BAIDU_UNLIKELY", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L564", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "callee": "PollingModeInitialize", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L565", "receiver": "UrmaEndpoint", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "callee": "move", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L566", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "callee": "move", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L566", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_initpollingmodewithtag", "callee": "move", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L567", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_releasepollingmodewithtag", "callee": "PollingModeRelease", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L571", "receiver": "UrmaEndpoint", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_registermemoryforurma", "callee": "BAIDU_UNLIKELY", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L579", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_registermemoryforurma", "callee": "urma_register_seg", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L595", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_registermemoryforurma", "callee": "PLOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L597", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_registermemoryforurma", "callee": "BAIDU_SCOPED_LOCK", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L600", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_registermemoryforurma", "callee": "insert", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L605", "receiver": "g_user_segs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_registermemoryforurma", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L606", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_registermemoryforurma", "callee": "urma_unregister_seg", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L607", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_deregistermemoryforurma", "callee": "BAIDU_UNLIKELY", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L614", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_deregistermemoryforurma", "callee": "BAIDU_SCOPED_LOCK", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L615", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_deregistermemoryforurma", "callee": "seek", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L616", "receiver": "g_user_segs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_deregistermemoryforurma", "callee": "urma_unregister_seg", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L618", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_deregistermemoryforurma", "callee": "erase", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L619", "receiver": "g_user_segs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_getseghandle", "callee": "BAIDU_SCOPED_LOCK", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L633", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_getseghandle", "callee": "begin", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L635", "receiver": "g_user_segs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_getseghandle", "callee": "end", "is_member_call": true, "source_file": "urma_helper.cpp", "source_location": "L635", "receiver": "g_user_segs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "callee": "LOG", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L661", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_helper_globalurmainitializeordie", "callee": "exit", "is_member_call": false, "source_file": "urma_helper.cpp", "source_location": "L662", "receiver": null, "lang": "cpp"}], "cpp_type_table": {"path": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp", "table": {"us": "UserSeg"}}}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/608feeb18131c6633a1d3bae5ce1bdaf944a337cafc10e12152fa2915751f7d0.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/608feeb18131c6633a1d3bae5ce1bdaf944a337cafc10e12152fa2915751f7d0.json
deleted file mode 100644
index 5dc5ce90e5..0000000000
--- a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/608feeb18131c6633a1d3bae5ce1bdaf944a337cafc10e12152fa2915751f7d0.json
+++ /dev/null
@@ -1 +0,0 @@
-{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "label": "mock_urma.cpp", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L1"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate", "label": "JfcState", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L54", "_callable": true}, {"id": "mutex", "label": "mutex", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate_mutex", "label": "mutex", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L55"}, {"id": "deque", "label": "deque", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "urma_cr_t", "label": "urma_cr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate_completions", "label": "completions", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L56"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate_event_pending", "label": "event_pending", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L57"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv", "label": "PendingRecv", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L60", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv_addr", "label": "addr", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L61"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv_len", "label": "len", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L62"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L63"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pushcompletion", "label": "PushCompletion()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L83", "_callable": true}, {"id": "urma_jfc_t", "label": "urma_jfc_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_init", "label": "urma_init()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L122", "_callable": true}, {"id": "urma_status_t", "label": "urma_status_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "urma_init_attr_t", "label": "urma_init_attr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "label": "urma_uninit()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L131", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "label": "urma_get_device_list()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L155", "_callable": true}, {"id": "urma_device_t", "label": "urma_device_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "label": "urma_get_device_by_name()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L195", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_free_device_list", "label": "urma_free_device_list()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L233", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_query_device", "label": "urma_query_device()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L239", "_callable": true}, {"id": "urma_device_attr_t", "label": "urma_device_attr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_eid_list", "label": "urma_get_eid_list()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L252", "_callable": true}, {"id": "urma_eid_info_t", "label": "urma_eid_info_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_free_eid_list", "label": "urma_free_eid_list()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L262", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_context", "label": "urma_create_context()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L268", "_callable": true}, {"id": "urma_context_t", "label": "urma_context_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_context", "label": "urma_delete_context()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L280", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfce", "label": "urma_create_jfce()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L290", "_callable": true}, {"id": "urma_jfce_t", "label": "urma_jfce_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfce", "label": "urma_delete_jfce()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L308", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfc", "label": "urma_create_jfc()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L319", "_callable": true}, {"id": "urma_jfc_cfg_t", "label": "urma_jfc_cfg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfc", "label": "urma_delete_jfc()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L337", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfr", "label": "urma_create_jfr()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L348", "_callable": true}, {"id": "urma_jfr_t", "label": "urma_jfr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "urma_jfr_cfg_t", "label": "urma_jfr_cfg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfr", "label": "urma_delete_jfr()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L364", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_register_seg", "label": "urma_register_seg()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L376", "_callable": true}, {"id": "urma_target_seg_t", "label": "urma_target_seg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "urma_seg_cfg_t", "label": "urma_seg_cfg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unregister_seg", "label": "urma_unregister_seg()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L392", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_seg", "label": "urma_import_seg()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L402", "_callable": true}, {"id": "urma_seg_t", "label": "urma_seg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "urma_token_t", "label": "urma_token_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "urma_import_seg_flag_t", "label": "urma_import_seg_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_seg", "label": "urma_unimport_seg()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L417", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_async_event", "label": "urma_get_async_event()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L427", "_callable": true}, {"id": "urma_async_event_t", "label": "urma_async_event_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_ack_async_event", "label": "urma_ack_async_event()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L439", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jetty", "label": "urma_create_jetty()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L441", "_callable": true}, {"id": "urma_jetty_t", "label": "urma_jetty_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "urma_jetty_cfg_t", "label": "urma_jetty_cfg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jetty", "label": "urma_delete_jetty()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L458", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unbind_jetty", "label": "urma_unbind_jetty()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L469", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_jetty", "label": "urma_import_jetty()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L478", "_callable": true}, {"id": "urma_target_jetty_t", "label": "urma_target_jetty_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "urma_rjetty_t", "label": "urma_rjetty_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_jetty", "label": "urma_unimport_jetty()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L493", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_bind_jetty", "label": "urma_bind_jetty()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L503", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_modify_jetty", "label": "urma_modify_jetty()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L514", "_callable": true}, {"id": "urma_jetty_attr_t", "label": "urma_jetty_attr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "label": "urma_post_jetty_send_wr()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L522", "_callable": true}, {"id": "urma_jfs_wr_t", "label": "urma_jfs_wr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jfr_wr", "label": "urma_post_jfr_wr()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L605", "_callable": true}, {"id": "urma_jfr_wr_t", "label": "urma_jfr_wr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "label": "urma_poll_jfc()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L627", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_rearm_jfc", "label": "urma_rearm_jfc()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L647", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_wait_jfc", "label": "urma_wait_jfc()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L651", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_ack_jfc", "label": "urma_ack_jfc()", "file_type": "code", "source_file": "mock_urma.cpp", "source_location": "L674", "_callable": true}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "urma_api", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L38", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "algorithm", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L40", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "atomic", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L41", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "cerrno", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L42", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "cstring", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L43", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "deque", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L44", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "map", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L45", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "mutex", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L46", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "shared_mutex", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L47", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "eventfd", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L48", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "unistd", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L49", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "vector", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L50", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L54", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate", "target": "mutex", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L55", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate_mutex", "relation": "defines", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L55", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate", "target": "deque", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L56", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate", "target": "urma_cr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L56", "weight": 1.0, "context": "generic_arg"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate_completions", "relation": "defines", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L56", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate_event_pending", "relation": "defines", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L57", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L60", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L61", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L62", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pendingrecv_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L63", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pushcompletion", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L83", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pushcompletion", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L83", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pushcompletion", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_jfcstate", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L83", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pushcompletion", "target": "urma_cr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L83", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_init", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L122", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_init", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L122", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_init", "target": "urma_init_attr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L122", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L131", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L131", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L155", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "target": "urma_device_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L155", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L195", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "target": "urma_device_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L195", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_free_device_list", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L233", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_free_device_list", "target": "urma_device_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L233", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_query_device", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L239", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_query_device", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L239", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_query_device", "target": "urma_device_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L239", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_query_device", "target": "urma_device_attr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L239", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_eid_list", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L252", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_eid_list", "target": "urma_eid_info_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L252", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_eid_list", "target": "urma_device_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L252", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_free_eid_list", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L262", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_free_eid_list", "target": "urma_eid_info_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L262", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_context", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L268", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_context", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L268", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_context", "target": "urma_device_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L268", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_context", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L280", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_context", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L280", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_context", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L280", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfce", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L290", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfce", "target": "urma_jfce_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L290", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfce", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L290", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfce", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L308", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfce", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L308", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfce", "target": "urma_jfce_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L308", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfc", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L319", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfc", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L319", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfc", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L319", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfc", "target": "urma_jfc_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L319", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfc", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L337", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfc", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L337", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfc", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L337", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L348", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfr", "target": "urma_jfr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L348", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfr", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L348", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfr", "target": "urma_jfr_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L348", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L364", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfr", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L364", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfr", "target": "urma_jfr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L364", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_register_seg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L376", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_register_seg", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L376", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_register_seg", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L376", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_register_seg", "target": "urma_seg_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L376", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unregister_seg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L392", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unregister_seg", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L392", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unregister_seg", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L392", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_seg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L402", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_seg", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L402", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_seg", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L402", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_seg", "target": "urma_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L402", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_seg", "target": "urma_token_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L402", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_seg", "target": "urma_import_seg_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L402", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_seg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L417", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_seg", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L417", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_seg", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L417", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_async_event", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L427", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_async_event", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L427", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_async_event", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L427", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_async_event", "target": "urma_async_event_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L427", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_ack_async_event", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L439", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_ack_async_event", "target": "urma_async_event_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L439", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L441", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jetty", "target": "urma_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L441", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jetty", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L441", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jetty", "target": "urma_jetty_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L441", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L458", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jetty", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L458", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jetty", "target": "urma_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L458", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unbind_jetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L469", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unbind_jetty", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L469", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unbind_jetty", "target": "urma_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L469", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_jetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L478", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_jetty", "target": "urma_target_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L478", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_jetty", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L478", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_jetty", "target": "urma_rjetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L478", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_jetty", "target": "urma_token_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L478", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_jetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L493", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_jetty", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L493", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_jetty", "target": "urma_target_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L493", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_bind_jetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L503", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_bind_jetty", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L503", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_bind_jetty", "target": "urma_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L503", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_bind_jetty", "target": "urma_target_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L503", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_modify_jetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L514", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_modify_jetty", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L514", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_modify_jetty", "target": "urma_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L514", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_modify_jetty", "target": "urma_jetty_attr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L514", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L522", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L522", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "target": "urma_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L522", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "target": "urma_jfs_wr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L522", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "target": "urma_jfs_wr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L522", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jfr_wr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L605", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jfr_wr", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L605", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jfr_wr", "target": "urma_jfr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L605", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jfr_wr", "target": "urma_jfr_wr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L605", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jfr_wr", "target": "urma_jfr_wr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L605", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L627", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L627", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "target": "urma_cr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L627", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_rearm_jfc", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L647", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_rearm_jfc", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L647", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_rearm_jfc", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L647", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_wait_jfc", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L651", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_wait_jfc", "target": "urma_jfce_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L651", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_wait_jfc", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L651", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_ack_jfc", "relation": "contains", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L674", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_ack_jfc", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L674", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pushcompletion", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "mock_urma.cpp", "source_location": "L543", "weight": 1.0}], "raw_calls": [{"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pushcompletion", "callee": "push_back", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L88", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_pushcompletion", "callee": "write", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L97", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L137", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L138", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L139", "receiver": "jfce_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L143", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L144", "receiver": "jfr_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L145", "receiver": "jfr_jfc_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L146", "receiver": "jfr_recv_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L147", "receiver": "seg_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L148", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L149", "receiver": "jetty_id_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "clear", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L150", "receiver": "target_jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_uninit", "callee": "store", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L151", "receiver": "next_jetty_id", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "empty", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L162", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "size", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L163", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "size", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L164", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "size", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L165", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "empty", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L177", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "strcpy", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L179", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "strcpy", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L180", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "push_back", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L184", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "size", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L186", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "size", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L187", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_list", "callee": "size", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L188", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "callee": "empty", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L201", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "callee": "strcmp", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L203", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "callee": "empty", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L215", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "callee": "strcpy", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L217", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "callee": "strcpy", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L218", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "callee": "push_back", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L222", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "callee": "strcmp", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L225", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_device_by_name", "callee": "empty", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L229", "receiver": "device_list", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_query_device", "callee": "memcpy", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L248", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_eid_list", "callee": "memcpy", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L258", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_context", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L282", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_context", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L282", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_context", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L285", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfce", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L292", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfce", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L292", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfce", "callee": "eventfd", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L299", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfce", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L310", "receiver": "jfce_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfce", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L310", "receiver": "jfce_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfce", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L313", "receiver": "jfce_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfce", "callee": "close", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L314", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfc", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L321", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfc", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L321", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfc", "callee": "memset", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L325", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfc", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L339", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfc", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L339", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfc", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L343", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfr", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L350", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jfr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L350", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfr", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L366", "receiver": "jfr_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L366", "receiver": "jfr_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfr", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L369", "receiver": "jfr_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfr", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L370", "receiver": "jfr_jfc_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jfr", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L371", "receiver": "jfr_recv_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_register_seg", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L378", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_register_seg", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L378", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_register_seg", "callee": "memset", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L382", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unregister_seg", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L394", "receiver": "seg_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unregister_seg", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L394", "receiver": "seg_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unregister_seg", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L397", "receiver": "seg_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_seg", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L407", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_seg", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L407", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_seg", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L419", "receiver": "seg_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_seg", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L419", "receiver": "seg_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_seg", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L422", "receiver": "seg_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_async_event", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L433", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_get_async_event", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L433", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jetty", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L443", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jetty", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L443", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jetty", "callee": "memset", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L447", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_create_jetty", "callee": "fetch_add", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L450", "receiver": "next_jetty_id", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jetty", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L460", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jetty", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L460", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jetty", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L463", "receiver": "jetty_id_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_delete_jetty", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L464", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unbind_jetty", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L471", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unbind_jetty", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L471", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_jetty", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L483", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_import_jetty", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L483", "receiver": "context_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_jetty", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L495", "receiver": "target_jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_jetty", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L495", "receiver": "target_jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_unimport_jetty", "callee": "erase", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L498", "receiver": "target_jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_bind_jetty", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L506", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_bind_jetty", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L506", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_bind_jetty", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L507", "receiver": "target_jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_bind_jetty", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L507", "receiver": "target_jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_modify_jetty", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L516", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_modify_jetty", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L516", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L525", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L527", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L528", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L529", "receiver": "jetty_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L530", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "unlock", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L535", "receiver": "read_lock", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L552", "receiver": "jetty_id_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L553", "receiver": "jetty_id_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L558", "receiver": "jfr_recv_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L559", "receiver": "jfr_jfc_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L560", "receiver": "jfr_recv_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "empty", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L560", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L561", "receiver": "jfr_jfc_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "front", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L564", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "pop_front", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L565", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "memcpy", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L574", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L582", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jetty_send_wr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L583", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jfr_wr", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L608", "receiver": "jfr_recv_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jfr_wr", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L609", "receiver": "jfr_recv_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_post_jfr_wr", "callee": "push_back", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L618", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "callee": "find", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L631", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "callee": "end", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L632", "receiver": "jfc_state_map", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "callee": "empty", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L637", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "callee": "front", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L638", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "callee": "pop_front", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L639", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_poll_jfc", "callee": "empty", "is_member_call": true, "source_file": "mock_urma.cpp", "source_location": "L641", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_mock_urma_urma_wait_jfc", "callee": "read", "is_member_call": false, "source_file": "mock_urma.cpp", "source_location": "L658", "receiver": null, "lang": "cpp"}], "cpp_type_table": {"path": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp", "table": {"remote_state": "JfcState", "recv": "PendingRecv", "local_state": "JfcState", "state": "JfcState"}}}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/6870b34881c2bda6a7406307467705c41b2381b7a5af286fab00d3241d6a5eca.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/6870b34881c2bda6a7406307467705c41b2381b7a5af286fab00d3241d6a5eca.json
deleted file mode 100644
index 9ccaeb8d17..0000000000
--- a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/6870b34881c2bda6a7406307467705c41b2381b7a5af286fab00d3241d6a5eca.json
+++ /dev/null
@@ -1 +0,0 @@
-{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "label": "urma_types.h", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_init_attr", "label": "urma_init_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L85", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_init_attr_token", "label": "token", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L86"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_init_attr_uasid", "label": "uasid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L87"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ref", "label": "urma_ref", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L152", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "label": "urma_port_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L160", "_callable": true}, {"id": "urma_mtu_t", "label": "urma_mtu_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_max_mtu", "label": "max_mtu", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L161"}, {"id": "urma_port_state_t", "label": "urma_port_state_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_state", "label": "state", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L162"}, {"id": "urma_link_width_t", "label": "urma_link_width_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_active_width", "label": "active_width", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L163"}, {"id": "urma_speed_t", "label": "urma_speed_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_active_speed", "label": "active_speed", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L164"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_active_mtu", "label": "active_mtu", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L165"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sl_info", "label": "urma_sl_info", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L178", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sl_info_sl", "label": "SL", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L179"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sl_info_tp_type", "label": "tp_type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L180"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "label": "urma_device_cap", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L254", "_callable": true}, {"id": "urma_device_feature_t", "label": "urma_device_feature_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_feature", "label": "feature", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L255"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfc", "label": "max_jfc", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L256"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs", "label": "max_jfs", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L257"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfr", "label": "max_jfr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L258"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jetty", "label": "max_jetty", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L259"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jetty_grp", "label": "max_jetty_grp", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L260"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jetty_in_jetty_grp", "label": "max_jetty_in_jetty_grp", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L261"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfc_depth", "label": "max_jfc_depth", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L262"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs_depth", "label": "max_jfs_depth", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L263"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfr_depth", "label": "max_jfr_depth", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L264"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs_inline_len", "label": "max_jfs_inline_len", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L265"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs_sge", "label": "max_jfs_sge", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L266"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs_rsge", "label": "max_jfs_rsge", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L267"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfr_sge", "label": "max_jfr_sge", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L268"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_msg_size", "label": "max_msg_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L269"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_read_size", "label": "max_read_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L270"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_write_size", "label": "max_write_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L271"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_cas_size", "label": "max_cas_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L272"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_swap_size", "label": "max_swap_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L273"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_add_size", "label": "max_fetch_and_add_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L274"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_sub_size", "label": "max_fetch_and_sub_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L275"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_and_size", "label": "max_fetch_and_and_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L276"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_or_size", "label": "max_fetch_and_or_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L277"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_xor_size", "label": "max_fetch_and_xor_size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L278"}, {"id": "urma_atomic_feature_t", "label": "urma_atomic_feature_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_atomic_feat", "label": "atomic_feat", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L279"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_trans_mode", "label": "trans_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L280"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_congestion_ctrl_alg", "label": "congestion_ctrl_alg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L281"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_ceq_cnt", "label": "ceq_cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L282"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_tp_in_tpg", "label": "max_tp_in_tpg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L283"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_eid_cnt", "label": "max_eid_cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L284"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_page_size_cap", "label": "page_size_cap", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L285"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_oor_cnt", "label": "max_oor_cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L286"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_mn", "label": "mn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L287"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_netaddr_cnt", "label": "max_netaddr_cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L288"}, {"id": "urma_order_type_cap_t", "label": "urma_order_type_cap_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_rm_order_cap", "label": "rm_order_cap", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L289"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_rc_order_cap", "label": "rc_order_cap", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L290"}, {"id": "urma_tp_type_cap_t", "label": "urma_tp_type_cap_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_rm_tp_cap", "label": "rm_tp_cap", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L291"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_rc_tp_cap", "label": "rc_tp_cap", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L292"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_um_tp_cap", "label": "um_tp_cap", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L293"}, {"id": "urma_tp_feature_t", "label": "urma_tp_feature_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_tp_feature", "label": "tp_feature", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L294"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_priority_info", "label": "priority_info", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L295"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_guid", "label": "urma_guid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L298", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_guid_raw", "label": "raw", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L299"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "label": "urma_device_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L302", "_callable": true}, {"id": "urma_guid_t", "label": "urma_guid_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_guid", "label": "guid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L303"}, {"id": "urma_device_cap_t", "label": "urma_device_cap_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_dev_cap", "label": "dev_cap", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L304"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_port_cnt", "label": "port_cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L305"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_port_attr", "label": "port_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L306"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_reserved_jetty_id_min", "label": "reserved_jetty_id_min", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L307"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_reserved_jetty_id_max", "label": "reserved_jetty_id_max", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L308"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token", "label": "urma_token", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L312", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_token", "label": "token", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L313"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sysfs_dev", "label": "urma_sysfs_dev", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L316", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ops", "label": "urma_ops", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L318", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_provider_ops", "label": "urma_provider_ops", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L319", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry", "label": "urma_cc_entry", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L358", "_callable": true}, {"id": "urma_tp_cc_alg_t", "label": "urma_tp_cc_alg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry_alg", "label": "alg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L359"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry_cc_pattern_idx", "label": "cc_pattern_idx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L360"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry_cc_priority", "label": "cc_priority", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L361"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device", "label": "urma_device", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L364", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_name", "label": "name", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L365"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_path", "label": "path", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L367"}, {"id": "urma_transport_type_t", "label": "urma_transport_type_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_type", "label": "type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L368"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_ops", "label": "ops", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L369"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_sysfs_dev", "label": "sysfs_dev", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L370"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "label": "urma_context", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L383", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_dev", "label": "dev", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L384"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_ops", "label": "ops", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L385"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_dev_fd", "label": "dev_fd", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L386"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_async_fd", "label": "async_fd", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L387"}, {"id": "pthread_mutex_t", "label": "pthread_mutex_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_mutex", "label": "mutex", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L388"}, {"id": "urma_eid_t", "label": "urma_eid_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_eid", "label": "eid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L389"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_eid_index", "label": "eid_index", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L390"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_uasid", "label": "uasid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L391"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_ref", "label": "ref", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L392"}, {"id": "urma_context_aggr_mode_t", "label": "urma_context_aggr_mode_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_aggr_mode", "label": "aggr_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L393"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_eid_info", "label": "urma_eid_info", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L396", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_eid_info_eid", "label": "eid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L397"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_eid_info_eid_index", "label": "eid_index", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L398"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_cfg", "label": "urma_jfce_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L401", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_cfg_depth", "label": "depth", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L402"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_cfg_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L403"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce", "label": "urma_jfce", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L406", "_callable": true}, {"id": "urma_context_t", "label": "urma_context_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L407"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_fd", "label": "fd", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L408"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_ref", "label": "ref", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L409"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg", "label": "urma_jfc_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L423", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_depth", "label": "depth", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L424"}, {"id": "urma_jfc_flag_t", "label": "urma_jfc_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L425"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_ceqn", "label": "ceqn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L426"}, {"id": "urma_jfce_t", "label": "urma_jfce_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_jfce", "label": "jfce", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L428"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L429"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr", "label": "urma_jfc_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L437", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr_mask", "label": "mask", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L438"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr_moderate_count", "label": "moderate_count", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L439"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr_moderate_period", "label": "moderate_period", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L440"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id", "label": "urma_jetty_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L443", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id_eid", "label": "eid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L444"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id_uasid", "label": "uasid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L445"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id_id", "label": "id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L446"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "label": "urma_jfc_opt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L467", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_jfc_opt_mask", "label": "jfc_opt_mask", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L468"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_is_actived", "label": "is_actived", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L470"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_cqe_base_addr", "label": "urma_jfc_cqe_base_addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L471"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_id", "label": "urma_jfc_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L472"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_db_addr", "label": "urma_jfc_db_addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L473"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_db_status", "label": "urma_jfc_db_status", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L474"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_pi", "label": "urma_jfc_pi", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L475"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_pi_type", "label": "urma_jfc_pi_type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L476"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_ci", "label": "urma_jfc_ci", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L477"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_reserved", "label": "reserved", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L478"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "label": "urma_jfc", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L481", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L482"}, {"id": "urma_jfc_id_t", "label": "urma_jfc_id_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_jfc_id", "label": "jfc_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L483"}, {"id": "urma_jfc_cfg_t", "label": "urma_jfc_cfg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_jfc_cfg", "label": "jfc_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L484"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_handle", "label": "handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L485"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_event_mutex", "label": "event_mutex", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L486"}, {"id": "pthread_cond_t", "label": "pthread_cond_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_event_cond", "label": "event_cond", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L487"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_comp_events_acked", "label": "comp_events_acked", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L488"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_async_events_acked", "label": "async_events_acked", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L489"}, {"id": "urma_jfc_opt_t", "label": "urma_jfc_opt_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_urma_jfc_opt", "label": "urma_jfc_opt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L490"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "label": "urma_jfs_opt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L534", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_jfs_opt_mask", "label": "jfs_opt_mask", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L535"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_is_actived", "label": "is_actived", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L537"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_sqe_base_addr", "label": "urma_jfs_sqe_base_addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L538"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_id", "label": "urma_jfs_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L539"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_db_addr", "label": "urma_jfs_db_addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L540"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_db_status", "label": "urma_jfs_db_status", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L541"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_pi", "label": "urma_jfs_pi", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L542"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_pi_type", "label": "urma_jfs_pi_type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L543"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_ci", "label": "urma_jfs_ci", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L544"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_reserved", "label": "reserved", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L545"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "label": "urma_jfs_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L548", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_depth", "label": "depth", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L549"}, {"id": "urma_jfs_flag_t", "label": "urma_jfs_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L550"}, {"id": "urma_transport_mode_t", "label": "urma_transport_mode_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_trans_mode", "label": "trans_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L551"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_priority", "label": "priority", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L552"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_max_sge", "label": "max_sge", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L554"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_max_rsge", "label": "max_rsge", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L555"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_max_inline_data", "label": "max_inline_data", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L556"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_rnr_retry", "label": "rnr_retry", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L558"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_err_timeout", "label": "err_timeout", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L562"}, {"id": "urma_jfc_t", "label": "urma_jfc_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_jfc", "label": "jfc", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L564"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L565"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "label": "urma_jfs", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L568", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L569"}, {"id": "urma_jfs_id_t", "label": "urma_jfs_id_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_jfs_id", "label": "jfs_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L570"}, {"id": "urma_jfs_cfg_t", "label": "urma_jfs_cfg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_jfs_cfg", "label": "jfs_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L571"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_handle", "label": "handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L572"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_event_mutex", "label": "event_mutex", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L573"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_event_cond", "label": "event_cond", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L574"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_async_events_acked", "label": "async_events_acked", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L575"}, {"id": "urma_jfs_opt_t", "label": "urma_jfs_opt_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_urma_jfs_opt", "label": "urma_jfs_opt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L576"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_attr", "label": "urma_jfs_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L585", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_attr_mask", "label": "mask", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L586"}, {"id": "urma_jfs_state_t", "label": "urma_jfs_state_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_attr_state", "label": "state", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L587"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "label": "urma_jfr_opt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L625", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_jfr_opt_mask", "label": "jfr_opt_mask", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L626"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_is_actived", "label": "is_actived", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L628"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_rqe_base_addr", "label": "urma_jfr_rqe_base_addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L629"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_id", "label": "urma_jfr_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L630"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_db_addr", "label": "urma_jfr_db_addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L631"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_db_status", "label": "urma_jfr_db_status", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L632"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_pi", "label": "urma_jfr_pi", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L633"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_pi_type", "label": "urma_jfr_pi_type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L634"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_ci", "label": "urma_jfr_ci", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L635"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_reserved", "label": "reserved", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L636"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "label": "urma_jfr_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L639", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_id", "label": "id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L640"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_depth", "label": "depth", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L642"}, {"id": "urma_jfr_flag_t", "label": "urma_jfr_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L643"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_trans_mode", "label": "trans_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L644"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_max_sge", "label": "max_sge", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L645"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_min_rnr_timer", "label": "min_rnr_timer", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L646"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_jfc", "label": "jfc", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L648"}, {"id": "urma_token_t", "label": "urma_token_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_token_value", "label": "token_value", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L649"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L650"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr", "label": "urma_jfr_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L658", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr_mask", "label": "mask", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L659"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr_rx_threshold", "label": "rx_threshold", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L660"}, {"id": "urma_jfr_state_t", "label": "urma_jfr_state_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr_state", "label": "state", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L661"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "label": "urma_jfr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L664", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L665"}, {"id": "urma_jfr_id_t", "label": "urma_jfr_id_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_jfr_id", "label": "jfr_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L666"}, {"id": "urma_jfr_cfg_t", "label": "urma_jfr_cfg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_jfr_cfg", "label": "jfr_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L667"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_handle", "label": "handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L668"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_event_mutex", "label": "event_mutex", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L669"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_event_cond", "label": "event_cond", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L670"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_async_events_acked", "label": "async_events_acked", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L671"}, {"id": "urma_jfr_opt_t", "label": "urma_jfr_opt_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_urma_jfr_opt", "label": "urma_jfr_opt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L672"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "label": "urma_rjfr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L702", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr_jfr_id", "label": "jfr_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L703"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr_trans_mode", "label": "trans_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L704"}, {"id": "urma_import_jetty_flag_t", "label": "urma_import_jetty_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L705"}, {"id": "urma_tp_type_t", "label": "urma_tp_type_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr_tp_type", "label": "tp_type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L706"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp", "label": "urma_tp", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L709", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_tpn", "label": "tpn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L710"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "label": "urma_jetty_grp", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L724", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "label": "urma_jetty_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L726", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_id", "label": "id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L727"}, {"id": "urma_jetty_flag_t", "label": "urma_jetty_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L728"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_jfs_cfg", "label": "jfs_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L731"}, {"id": "urma_jetty_grp_t", "label": "urma_jetty_grp_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_jetty_grp", "label": "jetty_grp", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L741"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L742"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "label": "urma_rjetty", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L756", "_callable": true}, {"id": "urma_jetty_id_t", "label": "urma_jetty_id_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_jetty_id", "label": "jetty_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L757"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_trans_mode", "label": "trans_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L758"}, {"id": "urma_jetty_grp_policy_t", "label": "urma_jetty_grp_policy_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_policy", "label": "policy", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L759"}, {"id": "urma_target_type_t", "label": "urma_target_type_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_type", "label": "type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L760"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L761"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_tp_type", "label": "tp_type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L762"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "label": "urma_target_jetty", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L765", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L766"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_id", "label": "id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L767"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_handle", "label": "handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L768"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_trans_mode", "label": "trans_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L769"}, {"id": "urma_tp_t", "label": "urma_tp_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_tp", "label": "tp", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L770"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_type", "label": "type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L771"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L772"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_policy", "label": "policy", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L773"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_tp_type", "label": "tp_type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L774"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr", "label": "urma_jetty_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L782", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr_mask", "label": "mask", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L783"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr_rx_threshold", "label": "rx_threshold", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L784"}, {"id": "urma_jetty_state_t", "label": "urma_jetty_state_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr_state", "label": "state", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L785"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt", "label": "urma_jetty_opt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L788", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt_is_actived", "label": "is_actived", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L789"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt_jfs_opt", "label": "jfs_opt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L790"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt_reserved", "label": "reserved", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L791"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "label": "urma_jetty", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L794", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L795"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_jetty_id", "label": "jetty_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L796"}, {"id": "urma_target_jetty_t", "label": "urma_target_jetty_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_remote_jetty", "label": "remote_jetty", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L797"}, {"id": "urma_jetty_cfg_t", "label": "urma_jetty_cfg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_jetty_cfg", "label": "jetty_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L799"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_handle", "label": "handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L800"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_event_mutex", "label": "event_mutex", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L801"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_event_cond", "label": "event_cond", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L802"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_async_events_acked", "label": "async_events_acked", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L803"}, {"id": "urma_jetty_opt_t", "label": "urma_jetty_opt_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_urma_jetty_opt", "label": "urma_jetty_opt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L804"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier", "label": "urma_notifier", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L807", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L808"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier_fd", "label": "fd", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L809"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier_incomplete_tjetty_list", "label": "incomplete_tjetty_list", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L810"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify", "label": "urma_notify", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L818", "_callable": true}, {"id": "urma_notify_type_t", "label": "urma_notify_type_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify_type", "label": "type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L819"}, {"id": "urma_status_t", "label": "urma_status_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify_status", "label": "status", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L820"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L821"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "label": "urma_jetty_grp_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L840", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_name", "label": "name", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L841"}, {"id": "urma_jetty_grp_flag_t", "label": "urma_jetty_grp_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L842"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_token_value", "label": "token_value", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L843"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_id", "label": "id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L844"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_policy", "label": "policy", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L846"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L847"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L851"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_jetty_grp_id", "label": "jetty_grp_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L852"}, {"id": "urma_jetty_grp_cfg_t", "label": "urma_jetty_grp_cfg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_jetty_cnt", "label": "jetty_cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L854"}, {"id": "urma_jetty_t", "label": "urma_jetty_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_jetty_list", "label": "jetty_list", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L855"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_list_mutex", "label": "list_mutex", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L856"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_handle", "label": "handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L857"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_event_mutex", "label": "event_mutex", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L858"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_event_cond", "label": "event_cond", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L859"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_async_events_acked", "label": "async_events_acked", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L860"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva", "label": "urma_ubva", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L864", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva_eid", "label": "eid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L865"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva_uasid", "label": "uasid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L866"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva_va", "label": "va", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L867"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "label": "urma_token_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L946", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L947"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_token_id", "label": "token_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L948"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_handle", "label": "handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L949"}, {"id": "urma_ref_t", "label": "urma_ref_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_ref", "label": "ref", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L950"}, {"id": "urma_token_id_flag_t", "label": "urma_token_id_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L951"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "label": "urma_seg_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L954", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_va", "label": "va", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L955"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_len", "label": "len", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L956"}, {"id": "urma_token_id_t", "label": "urma_token_id_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_token_id", "label": "token_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L957"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_token_value", "label": "token_value", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L958"}, {"id": "urma_reg_seg_flag_t", "label": "urma_reg_seg_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L959"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L960"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_iova", "label": "iova", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L961"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg", "label": "urma_seg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L964", "_callable": true}, {"id": "urma_ubva_t", "label": "urma_ubva_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_ubva", "label": "ubva", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L965"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_len", "label": "len", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L966"}, {"id": "urma_seg_attr_t", "label": "urma_seg_attr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_attr", "label": "attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L967"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_token_id", "label": "token_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L968"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "label": "urma_target_seg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L971", "_callable": true}, {"id": "urma_seg_t", "label": "urma_seg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_seg", "label": "seg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L972"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L973"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_mva", "label": "mva", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L974"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L975"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_token_id", "label": "token_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L976"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_handle", "label": "handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L977"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in", "label": "urma_user_ctl_in", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L980", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in_addr", "label": "addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L981"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in_len", "label": "len", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L982"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in_opcode", "label": "opcode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L987"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out", "label": "urma_user_ctl_out", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L990", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out_addr", "label": "addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L991"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out_len", "label": "len", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L992"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out_reserved", "label": "reserved", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L993"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg", "label": "urma_user_target_seg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L996", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg_attr", "label": "attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L997"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg_token_id", "label": "token_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L998"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg_token_value", "label": "token_value", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L999"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge", "label": "urma_sge", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1002", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge_addr", "label": "addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1003"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge_len", "label": "len", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1004"}, {"id": "urma_target_seg_t", "label": "urma_target_seg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge_tseg", "label": "tseg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1010"}, {"id": "urma_user_tseg_t", "label": "urma_user_tseg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge_user_tseg", "label": "user_tseg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1011"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sg", "label": "urma_sg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1014", "_callable": true}, {"id": "urma_sge_t", "label": "urma_sge_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sg_sge", "label": "sge", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1015"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sg_num_sge", "label": "num_sge", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1016"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr", "label": "urma_rw_wr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1053", "_callable": true}, {"id": "urma_sg_t", "label": "urma_sg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr_src", "label": "src", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1054"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr_dst", "label": "dst", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1056"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr_target_hint", "label": "target_hint", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1058"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr_notify_data", "label": "notify_data", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1059"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr", "label": "urma_send_wr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1062", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr_src", "label": "src", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1063"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr_target_hint", "label": "target_hint", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1064"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr_imm_data", "label": "imm_data", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1065"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr_tseg", "label": "tseg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1066"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr", "label": "urma_cas_wr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1069", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr_dst", "label": "dst", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1070"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr_src", "label": "src", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1071"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr", "label": "urma_faa_wr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1082", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr_dst", "label": "dst", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1083"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr_src", "label": "src", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1084"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "label": "urma_jfs_wr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1091", "_callable": true}, {"id": "urma_opcode_t", "label": "urma_opcode_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_opcode", "label": "opcode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1092"}, {"id": "urma_jfs_wr_flag_t", "label": "urma_jfs_wr_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1093"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_tjetty", "label": "tjetty", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1094"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1095"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_next", "label": "next", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1102"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr", "label": "urma_jfr_wr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1105", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr_src", "label": "src", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1106"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1107"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr_next", "label": "next", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1108"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_token", "label": "urma_cr_token", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1122", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_token_token_id", "label": "token_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1123"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_token_token_value", "label": "token_value", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1124"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "label": "urma_cr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1127", "_callable": true}, {"id": "urma_cr_status_t", "label": "urma_cr_status_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_status", "label": "status", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1128"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1129"}, {"id": "urma_cr_opcode_t", "label": "urma_cr_opcode_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_opcode", "label": "opcode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1130"}, {"id": "urma_cr_flag_t", "label": "urma_cr_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1131"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_completion_len", "label": "completion_len", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1132"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_local_id", "label": "local_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1134"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_remote_id", "label": "remote_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1135"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_tpn", "label": "tpn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1141"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_user_data", "label": "user_data", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1142"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event", "label": "urma_async_event", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1145", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event_urma_ctx", "label": "urma_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1147"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event_element", "label": "element", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1156"}, {"id": "urma_async_event_type_t", "label": "urma_async_event_type_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event_event_type", "label": "event_type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1157"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event_priv", "label": "priv", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1158"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur", "label": "urma_ur", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1184", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_name", "label": "name", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1185"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_size", "label": "size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1186"}, {"id": "urma_ur_attr_t", "label": "urma_ur_attr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_attr", "label": "attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1187"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_token", "label": "token", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1188"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_user_ctx", "label": "user_ctx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1189"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur", "label": "urma_target_ur", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1193", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_name", "label": "name", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1194"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_size", "label": "size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1195"}, {"id": "urma_import_ur_flag_t", "label": "urma_import_ur_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1196"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_tseg_list", "label": "tseg_list", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1197"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_cnt", "label": "cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1198"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_info", "label": "urma_seg_info", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1201", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_info_seg", "label": "seg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1202"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_info_idx_in_ur", "label": "idx_in_ur", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1203"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info", "label": "urma_ur_info", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1207", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_name", "label": "name", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1208"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_size", "label": "size", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1209"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_attr", "label": "attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1210"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_cnt", "label": "cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1211"}, {"id": "urma_seg_info_t", "label": "urma_seg_info_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_seg_list", "label": "seg_list", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1212"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info", "label": "urma_jfr_info", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1215", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info_name", "label": "name", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1216"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info_eid", "label": "eid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1217"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info_uasid", "label": "uasid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1218"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info_id", "label": "id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1219"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "label": "urma_tp_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1238", "_callable": true}, {"id": "urma_tp_cfg_flag_t", "label": "urma_tp_cfg_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1239"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_trans_mode", "label": "trans_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1241"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_retry_num", "label": "retry_num", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1242"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_retry_factor", "label": "retry_factor", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1243"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_ack_timeout", "label": "ack_timeout", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1244"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_dscp", "label": "dscp", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1245"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_oor_cnt", "label": "oor_cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1246"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr", "label": "urma_net_addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1295", "_callable": true}, {"id": "sa_family_t", "label": "sa_family_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_sin_family", "label": "sin_family", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1296"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_vlan", "label": "vlan", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1301"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_mac", "label": "mac", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1302"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_prefix_len", "label": "prefix_len", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1303"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_info", "label": "urma_net_addr_info", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1306", "_callable": true}, {"id": "urma_net_addr_t", "label": "urma_net_addr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_info_netaddr", "label": "netaddr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1307"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_info_index", "label": "index", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1308"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "label": "urma_tp_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1311", "_callable": true}, {"id": "urma_tp_mod_flag_t", "label": "urma_tp_mod_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1312"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_peer_tpn", "label": "peer_tpn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1313"}, {"id": "urma_tp_state_t", "label": "urma_tp_state_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_state", "label": "state", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1314"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_tx_psn", "label": "tx_psn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1315"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_rx_psn", "label": "rx_psn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1316"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_mtu", "label": "mtu", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1317"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_cc_pattern_idx", "label": "cc_pattern_idx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1318"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_oos_cnt", "label": "oos_cnt", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1319"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_local_net_addr_idx", "label": "local_net_addr_idx", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1320"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_peer_net_addr", "label": "peer_net_addr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1321"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_data_udp_start", "label": "data_udp_start", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1322"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_ack_udp_start", "label": "ack_udp_start", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1323"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_udp_range", "label": "udp_range", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1324"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_hop_limit", "label": "hop_limit", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1325"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_flow_label", "label": "flow_label", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1326"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_port_id", "label": "port_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1327"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_mn", "label": "mn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1328"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_peer_trans_type", "label": "peer_trans_type", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1329"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "label": "urma_get_tp_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1347", "_callable": true}, {"id": "urma_get_tp_cfg_flag_t", "label": "urma_get_tp_cfg_flag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg_flag", "label": "flag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1348"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg_trans_mode", "label": "trans_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1349"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg_local_eid", "label": "local_eid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1350"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg_peer_eid", "label": "peer_eid", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1351"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_info", "label": "urma_tp_info", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1354", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_info_tp_handle", "label": "tp_handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1355"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr", "label": "urma_active_tp_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1358", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr_tx_psn", "label": "tx_psn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1359"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr_rx_psn", "label": "rx_psn", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1360"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr_reserved", "label": "reserved", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1361"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "label": "urma_active_tp_cfg", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1364", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg_tp_handle", "label": "tp_handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1365"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg_peer_tp_handle", "label": "peer_tp_handle", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1366"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg_tag", "label": "tag", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1367"}, {"id": "urma_active_tp_attr_t", "label": "urma_active_tp_attr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg_tp_attr", "label": "tp_attr", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1368"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "label": "urma_tp_attr_value", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1376", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_retry_times_init", "label": "retry_times_init", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1377"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_at", "label": "at", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1378"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_sip", "label": "sip", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1379"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_dip", "label": "dip", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1380"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_sma", "label": "sma", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1381"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_dma", "label": "dma", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1382"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_vlan_id", "label": "vlan_id", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1383"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_vlan_en", "label": "vlan_en", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1384"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_dscp", "label": "dscp", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1385"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_at_times", "label": "at_times", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1386"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_sl", "label": "sl", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1387"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_ttl", "label": "ttl", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1388"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_ack_udp_srcport", "label": "ack_udp_srcport", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1389"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_data_udp_srcport", "label": "data_udp_srcport", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1390"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_udp_srcport_range", "label": "udp_srcport_range", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1391"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_spray_en", "label": "spray_en", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1392"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_udp_global_en", "label": "udp_global_en", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1393"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_reserve_0", "label": "reserve_0", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1394"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_sl_bitmap", "label": "sl_bitmap", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1395"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_dscp_config_mode", "label": "dscp_config_mode", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1396"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_reserve_1", "label": "reserve_1", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1397"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_reserved", "label": "reserved", "file_type": "code", "source_file": "sdk/urma/urma_types.h", "source_location": "L1398"}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "inet", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L14", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "pthread", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L15", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "stdint", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L16", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "stdbool", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L17", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "socket", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L18", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "stdatomic", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L21", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "atomic", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L23", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "urma_opcode", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L26", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_init_attr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L85", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_init_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_init_attr_token", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L86", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_init_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_init_attr_uasid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L87", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ref", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L152", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L160", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "urma_mtu_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L161", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_max_mtu", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L161", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "urma_port_state_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L162", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_state", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L162", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "urma_link_width_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L163", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_active_width", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L163", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "urma_speed_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L164", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_active_speed", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L164", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "urma_mtu_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L165", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_port_attr_active_mtu", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L165", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sl_info", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L178", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sl_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sl_info_sl", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L179", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sl_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sl_info_tp_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L180", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L254", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "urma_device_feature_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L255", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_feature", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L255", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfc", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L256", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L257", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L258", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jetty", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L259", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jetty_grp", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L260", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jetty_in_jetty_grp", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L261", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfc_depth", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L262", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs_depth", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L263", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfr_depth", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L264", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs_inline_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L265", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs_sge", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L266", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfs_rsge", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L267", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_jfr_sge", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L268", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_msg_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L269", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_read_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L270", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_write_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L271", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_cas_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L272", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_swap_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L273", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_add_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L274", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_sub_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L275", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_and_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L276", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_or_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L277", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_fetch_and_xor_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L278", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "urma_atomic_feature_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L279", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_atomic_feat", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L279", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_trans_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L280", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_congestion_ctrl_alg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L281", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_ceq_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L282", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_tp_in_tpg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L283", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_eid_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L284", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_page_size_cap", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L285", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_oor_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L286", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_mn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L287", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_max_netaddr_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L288", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "urma_order_type_cap_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L289", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_rm_order_cap", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L289", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "urma_order_type_cap_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L290", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_rc_order_cap", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L290", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "urma_tp_type_cap_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L291", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_rm_tp_cap", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L291", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "urma_tp_type_cap_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L292", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_rc_tp_cap", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L292", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "urma_tp_type_cap_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L293", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_um_tp_cap", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L293", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "urma_tp_feature_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L294", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_tp_feature", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L294", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_cap_priority_info", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L295", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_guid", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L298", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_guid", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_guid_raw", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L299", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L302", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "target": "urma_guid_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L303", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_guid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L303", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "target": "urma_device_cap_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L304", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_dev_cap", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L304", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_port_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L305", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_port_attr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L306", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_reserved_jetty_id_min", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L307", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_attr_reserved_jetty_id_max", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L308", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L312", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_token", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L313", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sysfs_dev", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L316", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ref", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L317", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ops", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L318", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_provider_ops", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L319", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L358", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry", "target": "urma_tp_cc_alg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L359", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry_alg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L359", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry_cc_pattern_idx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L360", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cc_entry_cc_priority", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L361", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L364", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_name", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L365", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_path", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L367", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device", "target": "urma_transport_type_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L368", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L368", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_ops", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L369", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_device_sysfs_dev", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L370", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L383", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_dev", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L384", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_ops", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L385", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_dev_fd", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L386", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_async_fd", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L387", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "pthread_mutex_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L388", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_mutex", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L388", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "urma_eid_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L389", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L389", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_eid_index", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L390", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_uasid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L391", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_ref", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L392", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "urma_context_aggr_mode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L393", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_context_aggr_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L393", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_eid_info", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L396", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_eid_info", "target": "urma_eid_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L397", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_eid_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_eid_info_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L397", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_eid_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_eid_info_eid_index", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L398", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L401", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_cfg_depth", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L402", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_cfg_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L403", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L406", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L407", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L407", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_fd", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L408", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfce_ref", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L409", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L423", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_depth", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L424", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg", "target": "urma_jfc_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L425", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L425", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_ceqn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L426", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg", "target": "urma_jfce_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L428", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_jfce", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L428", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_cfg_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L429", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L437", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr_mask", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L438", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr_moderate_count", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L439", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_attr_moderate_period", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L440", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L443", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id", "target": "urma_eid_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L444", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L444", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id_uasid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L445", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L446", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L449", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L450", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_id", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L451", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L467", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_jfc_opt_mask", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L468", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_is_actived", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L470", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_cqe_base_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L471", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L472", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_db_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L473", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_db_status", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L474", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_pi", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L475", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_pi_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L476", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_urma_jfc_ci", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L477", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_opt_reserved", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L478", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L481", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L482", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L482", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "urma_jfc_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L483", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_jfc_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L483", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "urma_jfc_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L484", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_jfc_cfg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L484", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L485", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "pthread_mutex_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L486", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_event_mutex", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L486", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "pthread_cond_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L487", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_event_cond", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L487", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_comp_events_acked", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L488", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_async_events_acked", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L489", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "urma_jfc_opt_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L490", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfc_urma_jfc_opt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L490", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L534", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_jfs_opt_mask", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L535", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_is_actived", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L537", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_sqe_base_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L538", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L539", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_db_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L540", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_db_status", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L541", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_pi", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L542", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_pi_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L543", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_urma_jfs_ci", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L544", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_opt_reserved", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L545", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L548", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_depth", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L549", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "urma_jfs_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L550", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L550", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "urma_transport_mode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L551", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_trans_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L551", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_priority", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L552", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_max_sge", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L554", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_max_rsge", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L555", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_max_inline_data", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L556", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_rnr_retry", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L558", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_err_timeout", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L562", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L564", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_jfc", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L564", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_cfg_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L565", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L568", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L569", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L569", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "urma_jfs_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L570", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_jfs_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L570", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "urma_jfs_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L571", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_jfs_cfg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L571", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L572", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "pthread_mutex_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L573", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_event_mutex", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L573", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "pthread_cond_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L574", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_event_cond", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L574", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_async_events_acked", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L575", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "urma_jfs_opt_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L576", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_urma_jfs_opt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L576", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_attr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L585", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_attr_mask", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L586", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_attr", "target": "urma_jfs_state_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L587", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_attr_state", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L587", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L625", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_jfr_opt_mask", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L626", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_is_actived", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L628", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_rqe_base_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L629", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L630", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_db_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L631", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_db_status", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L632", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_pi", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L633", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_pi_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L634", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_urma_jfr_ci", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L635", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_opt_reserved", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L636", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L639", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L640", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_depth", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L642", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "urma_jfr_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L643", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L643", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "urma_transport_mode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L644", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_trans_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L644", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_max_sge", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L645", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_min_rnr_timer", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L646", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L648", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_jfc", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L648", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "urma_token_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L649", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_token_value", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L649", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_cfg_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L650", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L658", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr_mask", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L659", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr_rx_threshold", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L660", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr", "target": "urma_jfr_state_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L661", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_attr_state", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L661", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L664", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L665", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L665", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "urma_jfr_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L666", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_jfr_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L666", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "urma_jfr_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L667", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_jfr_cfg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L667", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L668", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "pthread_mutex_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L669", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_event_mutex", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L669", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "pthread_cond_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L670", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_event_cond", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L670", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_async_events_acked", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L671", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "urma_jfr_opt_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L672", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_urma_jfr_opt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L672", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L702", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "target": "urma_jfr_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L703", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr_jfr_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L703", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "target": "urma_transport_mode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L704", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr_trans_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L704", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "target": "urma_import_jetty_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L705", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L705", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "target": "urma_tp_type_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L706", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjfr_tp_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L706", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L709", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_tpn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L710", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L724", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L726", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L727", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "target": "urma_jetty_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L728", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L728", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "target": "urma_jfs_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L731", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_jfs_cfg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L731", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "target": "urma_jetty_grp_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L741", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_jetty_grp", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L741", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_cfg_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L742", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L756", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "urma_jetty_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L757", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_jetty_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L757", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "urma_transport_mode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L758", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_trans_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L758", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "urma_jetty_grp_policy_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L759", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_policy", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L759", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "urma_target_type_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L760", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L760", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "urma_import_jetty_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L761", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L761", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "urma_tp_type_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L762", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rjetty_tp_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L762", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L765", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L766", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L766", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "urma_jetty_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L767", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L767", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L768", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "urma_transport_mode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L769", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_trans_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L769", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "urma_tp_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L770", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_tp", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L770", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "urma_target_type_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L771", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L771", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "urma_import_jetty_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L772", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L772", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "urma_jetty_grp_policy_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L773", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_policy", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L773", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "urma_tp_type_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L774", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_jetty_tp_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L774", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L782", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr_mask", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L783", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr_rx_threshold", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L784", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr", "target": "urma_jetty_state_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L785", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_attr_state", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L785", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L788", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt_is_actived", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L789", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt", "target": "urma_jfs_opt_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L790", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt_jfs_opt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L790", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_opt_reserved", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L791", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L794", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L795", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L795", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "urma_jetty_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L796", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_jetty_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L796", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "urma_target_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L797", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_remote_jetty", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L797", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "urma_jetty_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L799", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_jetty_cfg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L799", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L800", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "pthread_mutex_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L801", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_event_mutex", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L801", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "pthread_cond_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L802", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_event_cond", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L802", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_async_events_acked", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L803", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "urma_jetty_opt_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L804", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_urma_jetty_opt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L804", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L807", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L808", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L808", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier_fd", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L809", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notifier_incomplete_tjetty_list", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L810", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L818", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify", "target": "urma_notify_type_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L819", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L819", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify", "target": "urma_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L820", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify_status", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L820", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_notify_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L821", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L840", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_name", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L841", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "target": "urma_jetty_grp_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L842", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L842", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "target": "urma_token_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L843", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_token_value", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L843", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L844", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "target": "urma_jetty_grp_policy_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L846", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_policy", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L846", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L847", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L850", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L851", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L851", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "urma_jetty_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L852", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_jetty_grp_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L852", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "urma_jetty_grp_cfg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L853", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_cfg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L853", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_jetty_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L854", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "urma_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L855", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_jetty_list", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L855", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "pthread_mutex_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L856", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_list_mutex", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L856", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L857", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "pthread_mutex_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L858", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_event_mutex", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L858", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "pthread_cond_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L859", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_event_cond", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L859", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jetty_grp_async_events_acked", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L860", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L864", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva", "target": "urma_eid_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L865", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L865", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva_uasid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L866", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ubva_va", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L867", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L946", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L947", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L947", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_token_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L948", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L949", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "target": "urma_ref_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L950", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_ref", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L950", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "target": "urma_token_id_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L951", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_token_id_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L951", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L954", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_va", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L955", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L956", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "urma_token_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L957", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_token_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L957", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "urma_token_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L958", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_token_value", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L958", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "urma_reg_seg_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L959", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L959", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L960", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_cfg_iova", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L961", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L964", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg", "target": "urma_ubva_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L965", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_ubva", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L965", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L966", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg", "target": "urma_seg_attr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L967", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_attr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L967", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_token_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L968", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L971", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "target": "urma_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L972", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_seg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L972", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L973", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_mva", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L974", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L975", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L975", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "target": "urma_token_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L976", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_token_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L976", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_seg_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L977", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L980", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L981", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L982", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_in_opcode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L987", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L990", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L991", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L992", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_ctl_out_reserved", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L993", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L996", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg", "target": "urma_seg_attr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L997", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg_attr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L997", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg_token_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L998", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg", "target": "urma_token_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L999", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_user_target_seg_token_value", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L999", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1002", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1003", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1004", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1010", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge_tseg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1010", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge", "target": "urma_user_tseg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1011", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sge_user_tseg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1011", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1014", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sg", "target": "urma_sge_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1015", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sg_sge", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1015", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_sg_num_sge", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1016", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1053", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr", "target": "urma_sg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1054", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr_src", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1054", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr", "target": "urma_sg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1056", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr_dst", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1056", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr_target_hint", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1058", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_rw_wr_notify_data", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1059", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1062", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr", "target": "urma_sg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1063", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr_src", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1063", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr_target_hint", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1064", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr_imm_data", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1065", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1066", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_send_wr_tseg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1066", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1069", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr", "target": "urma_sge_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1070", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr_dst", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1070", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr", "target": "urma_sge_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1071", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cas_wr_src", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1071", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1082", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr", "target": "urma_sge_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1083", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr_dst", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1083", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr", "target": "urma_sge_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1084", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_faa_wr_src", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1084", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1091", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "target": "urma_opcode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1092", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_opcode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1092", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "target": "urma_jfs_wr_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1093", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1093", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "target": "urma_target_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1094", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_tjetty", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1094", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1095", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfs_wr_next", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1102", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1105", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr", "target": "urma_sg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1106", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr_src", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1106", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1107", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_wr_next", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1108", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_token", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1122", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_token", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_token_token_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1123", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_token", "target": "urma_token_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1124", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_token", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_token_token_value", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1124", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1127", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "urma_cr_status_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1128", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_status", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1128", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1129", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "urma_cr_opcode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1130", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_opcode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1130", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "urma_cr_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1131", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1131", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_completion_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1132", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_local_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1134", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "urma_jetty_id_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1135", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_remote_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1135", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_tpn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1141", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_cr_user_data", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1142", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1145", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event", "target": "urma_context_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1147", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event_urma_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1147", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event_element", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1156", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event", "target": "urma_async_event_type_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1157", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event_event_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1157", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_async_event_priv", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1158", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1184", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_name", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1185", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1186", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur", "target": "urma_ur_attr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1187", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_attr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1187", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_token", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1188", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_user_ctx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1189", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1193", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_name", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1194", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1195", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur", "target": "urma_import_ur_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1196", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1196", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1197", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_tseg_list", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1197", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_target_ur_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1198", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_info", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1201", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_info", "target": "urma_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1202", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_info_seg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1202", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_seg_info_idx_in_ur", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1203", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1207", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_name", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1208", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1209", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info", "target": "urma_ur_attr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1210", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_attr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1210", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1211", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info", "target": "urma_seg_info_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1212", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_ur_info_seg_list", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1212", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1215", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info_name", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1216", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info", "target": "urma_eid_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1217", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1217", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info_uasid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1218", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_jfr_info_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1219", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1238", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "target": "urma_tp_cfg_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1239", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1239", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "target": "urma_transport_mode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1241", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_trans_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1241", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_retry_num", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1242", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_retry_factor", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1243", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_ack_timeout", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1244", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_dscp", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1245", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_cfg_oor_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1246", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1295", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr", "target": "sa_family_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1296", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_sin_family", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1296", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_vlan", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1301", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_mac", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1302", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_prefix_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1303", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_info", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1306", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_info", "target": "urma_net_addr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1307", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_info_netaddr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1307", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_net_addr_info_index", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1308", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1311", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "urma_tp_mod_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1312", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1312", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_peer_tpn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1313", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "urma_tp_state_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1314", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_state", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1314", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_tx_psn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1315", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_rx_psn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1316", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "urma_mtu_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1317", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_mtu", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1317", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_cc_pattern_idx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1318", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_oos_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1319", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_local_net_addr_idx", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1320", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "urma_net_addr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1321", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_peer_net_addr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1321", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_data_udp_start", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1322", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_ack_udp_start", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1323", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_udp_range", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1324", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_hop_limit", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1325", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_flow_label", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1326", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_port_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1327", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_mn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1328", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "urma_transport_type_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1329", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_peer_trans_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1329", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1347", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "target": "urma_get_tp_cfg_flag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1348", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg_flag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1348", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "target": "urma_transport_mode_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1349", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg_trans_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1349", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "target": "urma_eid_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1350", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg_local_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1350", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "target": "urma_eid_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1351", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_get_tp_cfg_peer_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1351", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_info", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1354", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_info", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_info_tp_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1355", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1358", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr_tx_psn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1359", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr_rx_psn", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1360", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_attr_reserved", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1361", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1364", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg_tp_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1365", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg_peer_tp_handle", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1366", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg_tag", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1367", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "target": "urma_active_tp_attr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1368", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg_tp_attr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1368", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1371", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1372", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_active_tp_cfg", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1373", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "relation": "contains", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1376", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_retry_times_init", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1377", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_at", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1378", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_sip", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1379", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_dip", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1380", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_sma", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1381", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_dma", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1382", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_vlan_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1383", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_vlan_en", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1384", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_dscp", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1385", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_at_times", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1386", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_sl", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1387", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_ttl", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1388", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_ack_udp_srcport", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1389", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_data_udp_srcport", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1390", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_udp_srcport_range", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1391", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_spray_en", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1392", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_udp_global_en", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1393", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_reserve_0", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1394", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_sl_bitmap", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1395", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_dscp_config_mode", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1396", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_reserve_1", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1397", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_types_urma_tp_attr_value_reserved", "relation": "defines", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_types.h", "source_location": "L1398", "weight": 1.0, "context": "field"}], "raw_calls": []}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/7899e48f9378edf160c448d2d8eb8cdaa14683461e3f2562a4ce8dedce8721ed.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/7899e48f9378edf160c448d2d8eb8cdaa14683461e3f2562a4ce8dedce8721ed.json
deleted file mode 100644
index 0ffde6c745..0000000000
--- a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/7899e48f9378edf160c448d2d8eb8cdaa14683461e3f2562a4ce8dedce8721ed.json
+++ /dev/null
@@ -1 +0,0 @@
-{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "label": "urma_endpoint.h", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L1"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmatransport", "label": "UrmaTransport", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L42", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmahandshake", "label": "UrmaHandshake", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L46", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_parsedhello", "label": "ParsedHello", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L47", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect", "label": "UrmaConnect", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L56", "_callable": true}, {"id": "appconnect", "label": "AppConnect", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "label": "StartConnect", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L59"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_stopconnect", "label": "StopConnect", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L61"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_run", "label": "Run", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L70"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_data", "label": "_data", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L72"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_error", "label": "_error", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L73"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "label": "UrmaResource", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L81", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_next", "label": "next", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L82"}, {"id": "urma_jfc_t", "label": "urma_jfc_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_jfc", "label": "jfc", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L84"}, {"id": "urma_jfce_t", "label": "urma_jfce_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_jfce", "label": "jfce", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L85"}, {"id": "urma_jfr_t", "label": "urma_jfr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_jfr", "label": "jfr", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L86"}, {"id": "urma_jetty_t", "label": "urma_jetty_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_jetty", "label": "jetty", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L87"}, {"id": "urma_target_jetty_t", "label": "urma_target_jetty_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_remote_jetty", "label": "remote_jetty", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L89"}, {"id": "urma_target_seg_t", "label": "urma_target_seg_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.h"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_remote_seg", "label": "remote_seg", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L90"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "label": ".UrmaResource()", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L92", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint", "label": "UrmaEndpoint()", "file_type": "code", "source_file": "urma_endpoint.h", "source_location": "L100", "_callable": true}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "cstdint", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L21", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "functional", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L22", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "vector", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L23", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "atomicops", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L25", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "iobuf", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L26", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "macros", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L27", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "mpsc_queue", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L28", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "types", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L29", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "socket", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L31", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "urma_api", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L35", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "urma_types", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L36", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "urma_handshake", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L37", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "urma_handshake", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L38", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmatransport", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L42", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmahandshake", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L46", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_parsedhello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L47", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L56", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect", "target": "appconnect", "relation": "inherits", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L56", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L59", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_stopconnect", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L61", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_run", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L70", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_data", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L72", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_error", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L73", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L81", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_next", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L82", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L84", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_jfc", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L84", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "urma_jfce_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L85", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_jfce", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L85", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "urma_jfr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L86", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_jfr", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L86", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "urma_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L87", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_jetty", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L87", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "urma_target_jetty_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L89", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_remote_jetty", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L89", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "urma_target_seg_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L90", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_remote_seg", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L90", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L92", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L100", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.h", "source_location": "L344", "weight": 1.0}], "raw_calls": [{"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint", "callee": "DISALLOW_COPY_AND_ASSIGN", "is_member_call": false, "source_file": "urma_endpoint.h", "source_location": "L334", "receiver": null, "lang": "cpp"}], "cpp_type_table": {"path": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.h", "table": {"_rbuf": "IOBuf>", "_sbuf": "IOBuf>", "_cq_sid": "SocketId", "_resource": "UrmaResource", "_socket": "Socket"}}}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/9ead6eae6b7ea7f4b18e3757e1e7d33a73a6879dca40078e12765880de1061a1.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/9ead6eae6b7ea7f4b18e3757e1e7d33a73a6879dca40078e12765880de1061a1.json
deleted file mode 100644
index 52450abd22..0000000000
--- a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/9ead6eae6b7ea7f4b18e3757e1e7d33a73a6879dca40078e12765880de1061a1.json
+++ /dev/null
@@ -1 +0,0 @@
-{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "label": "urma_handshake.h", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L1"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "label": "UrmaEndpoint", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L32", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "label": "ParsedHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L38", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_buffer_size", "label": "buffer_size", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L39"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_recv_buffer_cnt", "label": "recv_buffer_cnt", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L40"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_jetty_id", "label": "jetty_id", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L41"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_eid", "label": "eid", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L42"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_uasid", "label": "uasid", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L43"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_tp_type", "label": "tp_type", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L44"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_eid", "label": "seg_eid", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L47"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_uasid", "label": "seg_uasid", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L48"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_va", "label": "seg_va", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L49"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_len", "label": "seg_len", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L50"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_token_id", "label": "seg_token_id", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L51"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "label": "HelloMessage", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L73", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_msg_len", "label": "msg_len", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L74"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_hello_ver", "label": "hello_ver", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L75"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_impl_ver", "label": "impl_ver", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L76"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_buffer_size", "label": "buffer_size", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L77"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_recv_buffer_cnt", "label": "recv_buffer_cnt", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L78"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_jetty_id", "label": "jetty_id", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L79"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_eid", "label": "eid", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L80"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_uasid", "label": "uasid", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L81"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_tp_type", "label": "tp_type", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L82"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_pad", "label": "pad", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L83"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_eid", "label": "seg_eid", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L84"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_uasid", "label": "seg_uasid", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L85"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_va", "label": "seg_va", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L86"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_len", "label": "seg_len", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L87"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_token_id", "label": "seg_token_id", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L88"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "label": "Serialize", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L90"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "label": "Deserialize", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L91"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "label": "UrmaHandshake", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L97", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake_urmahandshake", "label": ".~UrmaHandshake()", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L99", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake_protocolversion", "label": "ProtocolVersion", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L100"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake_sendlocalhello", "label": "SendLocalHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L104"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake_receiveandparseremotehello", "label": "ReceiveAndParseRemoteHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L110"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2", "label": "UrmaHandshakeClientV2", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L114", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_urmahandshakeclientv2", "label": ".UrmaHandshakeClientV2()", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L116", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_protocolversion", "label": ".ProtocolVersion()", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L117", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_sendlocalhello", "label": "SendLocalHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L118"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_receiveandparseremotehello", "label": "ReceiveAndParseRemoteHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L119"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_ep", "label": "_ep", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L121"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2", "label": "UrmaHandshakeServerV2", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L124", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_urmahandshakeserverv2", "label": ".UrmaHandshakeServerV2()", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L126", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_protocolversion", "label": ".ProtocolVersion()", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L127", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "label": "SendLocalHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L128"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_receiveandparseremotehello", "label": "ReceiveAndParseRemoteHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L129"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_ep", "label": "_ep", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L131"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3", "label": "UrmaHandshakeClientV3", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L135", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_urmahandshakeclientv3", "label": ".UrmaHandshakeClientV3()", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L137", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_protocolversion", "label": ".ProtocolVersion()", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L138", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_sendlocalhello", "label": "SendLocalHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L139"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_receiveandparseremotehello", "label": "ReceiveAndParseRemoteHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L140"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_ep", "label": "_ep", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L142"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3", "label": "UrmaHandshakeServerV3", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L145", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_urmahandshakeserverv3", "label": ".UrmaHandshakeServerV3()", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L147", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_protocolversion", "label": ".ProtocolVersion()", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L148", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_sendlocalhello", "label": "SendLocalHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L149"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_receiveandparseremotehello", "label": "ReceiveAndParseRemoteHello", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L150"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_ep", "label": "_ep", "file_type": "code", "source_file": "urma_handshake.h", "source_location": "L152"}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "cstdint", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L21", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "cstring", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L22", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "string", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L23", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "urma_types", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L27", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L32", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L38", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_buffer_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L39", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_recv_buffer_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L40", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_jetty_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L41", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L42", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_uasid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L43", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_tp_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L44", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L47", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_uasid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L48", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_va", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L49", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L50", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_parsedhello_seg_token_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L51", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L73", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_msg_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L74", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_hello_ver", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L75", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_impl_ver", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L76", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_buffer_size", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L77", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_recv_buffer_cnt", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L78", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_jetty_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L79", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L80", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_uasid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L81", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_tp_type", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L82", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_pad", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L83", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_eid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L84", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_uasid", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L85", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_va", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L86", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_len", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L87", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_seg_token_id", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L88", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_serialize", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L90", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_hellomessage_deserialize", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L91", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L97", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake_urmahandshake", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L99", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake_protocolversion", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L100", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake_sendlocalhello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L104", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake_receiveandparseremotehello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L110", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L114", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "relation": "inherits", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L114", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_urmahandshakeclientv2", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L116", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_urmahandshakeclientv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L116", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_protocolversion", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L117", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_sendlocalhello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L118", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_receiveandparseremotehello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L119", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L121", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv2_ep", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L121", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L124", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "relation": "inherits", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L124", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_urmahandshakeserverv2", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L126", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_urmahandshakeserverv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L126", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_protocolversion", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L127", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_sendlocalhello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L128", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_receiveandparseremotehello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L129", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L131", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv2_ep", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L131", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L135", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "relation": "inherits", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L135", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_urmahandshakeclientv3", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L137", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_urmahandshakeclientv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L137", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_protocolversion", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L138", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_sendlocalhello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L139", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_receiveandparseremotehello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L140", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L142", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeclientv3_ep", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L142", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_h", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L145", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshake", "relation": "inherits", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L145", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_urmahandshakeserverv3", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L147", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_urmahandshakeserverv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L147", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_protocolversion", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L148", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_sendlocalhello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L149", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_receiveandparseremotehello", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L150", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmaendpoint", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L152", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_handshake_urmahandshakeserverv3_ep", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_handshake.h", "source_location": "L152", "weight": 1.0, "context": "field"}], "raw_calls": []}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/bb7775d86173e02925fc786db010956f4dd08aef5a92ffdbffd70a11effd1833.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/bb7775d86173e02925fc786db010956f4dd08aef5a92ffdbffd70a11effd1833.json
deleted file mode 100644
index 3373b3214b..0000000000
--- a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/bb7775d86173e02925fc786db010956f4dd08aef5a92ffdbffd70a11effd1833.json
+++ /dev/null
@@ -1 +0,0 @@
-{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "label": "urma_endpoint.cpp", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjetty", "label": "PreparedJetty", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L82", "_callable": true}, {"id": "urmaresource", "label": "UrmaResource", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjetty_res", "label": "res", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L83"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjettycount", "label": "PreparedJettyCount()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L89", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "label": "UrmaResource::~UrmaResource()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L125", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_urmaendpoint", "label": "UrmaEndpoint::UrmaEndpoint()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L138", "_callable": true}, {"id": "socket", "label": "Socket", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "label": "UrmaEndpoint::Reset()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L159", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readfromfd", "label": "UrmaEndpoint::ReadFromFd()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L188", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pushbacktoreadbuf", "label": "UrmaEndpoint::PushBackToReadBuf()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L215", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "label": "UrmaEndpoint::WriteToFd()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L219", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_makelocalparsedhello", "label": "UrmaEndpoint::MakeLocalParsedHello()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L239", "_callable": true}, {"id": "parsedhello", "label": "ParsedHello", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov2", "label": "UrmaEndpoint::FillLocalHelloV2()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L261", "_callable": true}, {"id": "hellomessage", "label": "HelloMessage", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "label": "UrmaEndpoint::FillLocalHelloV3()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L282", "_callable": true}, {"id": "urmahello", "label": "UrmaHello", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "label": "UrmaEndpoint::WriteHelloV3()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L298", "_callable": true}, {"id": "iobuf", "label": "IOBuf", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "label": "UrmaEndpoint::ReadAndParseHelloV3()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L327", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "label": "UrmaEndpoint::AllocateResources()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L360", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_deallocateresources", "label": "UrmaEndpoint::DeallocateResources()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L462", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "label": "UrmaEndpoint::ImportPeer()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L494", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf", "label": "UrmaIOBuf", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L546", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "label": ".cut_into_sglist()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L556", "_callable": true}, {"id": "urma_sge_t", "label": "urma_sge_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "label": "UrmaEndpoint::CutFromIOBufList()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L590", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_iswritable", "label": "UrmaEndpoint::IsWritable()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L664", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_dopostrecv", "label": "UrmaEndpoint::DoPostRecv()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L673", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_postrecv", "label": "UrmaEndpoint::PostRecv()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L687", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendimm", "label": "UrmaEndpoint::SendImm()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L727", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendack", "label": "UrmaEndpoint::SendAck()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L751", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "label": "UrmaEndpoint::HandleCompletion()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L761", "_callable": true}, {"id": "urma_cr_t", "label": "urma_cr_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "label": "UrmaEndpoint::PollCq()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L847", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_applyremotehello", "label": "UrmaEndpoint::ApplyRemoteHello()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L930", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "label": "UrmaEndpoint::OnNewDataFromTcp()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L953", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_tryreadontcp", "label": "UrmaEndpoint::TryReadOnTcp()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1010", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "label": "TryReadOnTcpDuringUrmaEst()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1016", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_fallbacktotcp", "label": "UrmaEndpoint::FallbackToTcp()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1042", "_callable": true}, {"id": "urmatransport", "label": "UrmaTransport", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "label": "UrmaEndpoint::FailHandshake()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1051", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "label": "UrmaEndpoint::ProcessHandshakeAtClient()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1072", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "label": "UrmaEndpoint::ProcessHandshakeAtServer()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1144", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "label": "UrmaConnect::StartConnect()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1240", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_stopconnect", "label": "UrmaConnect::StopConnect()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1279", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_run", "label": "UrmaConnect::Run()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1281", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_getstatestr", "label": "UrmaEndpoint::GetStateStr()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1293", "_callable": true}, {"id": "string", "label": "string", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_debuginfo", "label": "UrmaEndpoint::DebugInfo()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1313", "_callable": true}, {"id": "ostream", "label": "ostream", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "stringpiece", "label": "StringPiece", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "label": "UrmaEndpoint::WaitCqEvent()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1322", "_callable": true}, {"id": "socketuniqueptr", "label": "SocketUniquePtr", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "urma_jfc_t", "label": "urma_jfc_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reqnotifycq", "label": "UrmaEndpoint::ReqNotifyCq()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1353", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "label": "UrmaEndpoint::PollingModeInitialize()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1368", "_callable": true}, {"id": "bthread_tag_t", "label": "bthread_tag_t", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "function", "label": "function", "file_type": "code", "source_file": "", "source_location": "", "origin_file": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp"}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmoderelease", "label": "UrmaEndpoint::PollingModeRelease()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1462", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_polleraddcqsid", "label": "UrmaEndpoint::PollerAddCqSid()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1476", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollerremovecqsid", "label": "UrmaEndpoint::PollerRemoveCqSid()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1492", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "label": "UrmaEndpoint::GlobalInitialize()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1505", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalrelease", "label": "UrmaEndpoint::GlobalRelease()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1566", "_callable": true}, {"id": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_bringupjetty", "label": "UrmaEndpoint::BringUpJetty()", "file_type": "code", "source_file": "urma_endpoint.cpp", "source_location": "L1581", "_callable": true}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "urma_endpoint", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L18", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "algorithm", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L22", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "cstring", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L23", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "iostream", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L24", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "memory", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L25", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "string", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L26", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "unordered_set", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L27", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "utility", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L28", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "vector", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L29", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "resource", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L30", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "unistd", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L31", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "gflags", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L33", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "atomicops", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L35", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "iobuf", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L36", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "logging", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L37", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "macros", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L38", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "sys_byteorder", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L39", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "time", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L40", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "bthread", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L41", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "butex", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L42", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "input_messenger", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L44", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "socket", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L45", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "urma_api", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L46", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "urma_endpoint", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L47", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "urma_handshake", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L48", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "urma_handshake", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L49", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "urma_helper", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L50", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "urma_transport", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L51", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L82", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjetty", "target": "urmaresource", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L83", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjetty", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjetty_res", "relation": "defines", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L83", "weight": 1.0, "context": "field"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjettycount", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L89", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L125", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_urmaendpoint", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L138", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_urmaendpoint", "target": "socket", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L138", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_urmaendpoint", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L151", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L159", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readfromfd", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L188", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pushbacktoreadbuf", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L215", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L219", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_makelocalparsedhello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L239", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_makelocalparsedhello", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L239", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov2", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L261", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov2", "target": "hellomessage", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L261", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L282", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "target": "urmahello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L282", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L298", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "target": "urmahello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L298", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L312", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "target": "iobuf", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L312", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L327", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L327", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L360", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_deallocateresources", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L462", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L494", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L494", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L546", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf", "target": "iobuf", "relation": "inherits", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L546", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "relation": "method", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L556", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "target": "urma_sge_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L556", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "target": "iobuf", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L556", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L590", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "target": "iobuf", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L590", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_iswritable", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L664", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_dopostrecv", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L673", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_postrecv", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L687", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendimm", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L727", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendack", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L751", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L761", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "target": "urma_cr_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L761", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L847", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "target": "socket", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L847", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_applyremotehello", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L930", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_applyremotehello", "target": "parsedhello", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L930", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L953", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "target": "socket", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L953", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_tryreadontcp", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1010", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1016", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "target": "socket", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1016", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_fallbacktotcp", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1042", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_fallbacktotcp", "target": "urmatransport", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1042", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1051", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "target": "urmatransport", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1051", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1072", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1144", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1240", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "target": "socket", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1240", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_stopconnect", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1279", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_stopconnect", "target": "socket", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1279", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_run", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1281", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_getstatestr", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1293", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_getstatestr", "target": "string", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1293", "weight": 1.0, "context": "return_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_debuginfo", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1313", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_debuginfo", "target": "ostream", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1313", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_debuginfo", "target": "stringpiece", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1313", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1322", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "target": "socketuniqueptr", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1322", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "target": "urma_jfc_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1322", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reqnotifycq", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1353", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1368", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "target": "bthread_tag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1368", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "target": "function", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1368", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "target": "function", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1368", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "target": "function", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1368", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmoderelease", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1462", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmoderelease", "target": "bthread_tag_t", "relation": "references", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1462", "weight": 1.0, "context": "parameter_type"}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_polleraddcqsid", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1476", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollerremovecqsid", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1492", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1505", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalrelease", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1566", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_cpp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_bringupjetty", "relation": "contains", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1581", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L622", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1003", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "target": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjettycount", "relation": "calls", "context": "call", "confidence": "EXTRACTED", "source_file": "urma_endpoint.cpp", "source_location": "L1521", "weight": 1.0}], "raw_calls": [{"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjettycount", "callee": "getrlimit", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L97", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_preparedjettycount", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L113", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "callee": "urma_unimport_jetty", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L126", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "callee": "urma_unimport_seg", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L127", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "callee": "urma_delete_jetty", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L128", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "callee": "urma_delete_jfr", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L129", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "callee": "urma_delete_jfc", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L130", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaresource_urmaresource", "callee": "urma_delete_jfce", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L131", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_urmaendpoint", "callee": "butex_create_checked<butil::atomic<int>>", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L147", "receiver": "bthread", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_urmaendpoint", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L148", "receiver": "_read_butex", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_urmaendpoint", "callee": "DeallocateResources", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L152", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_urmaendpoint", "callee": "butex_destroy", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L154", "receiver": "bthread", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "callee": "DeallocateResources", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L160", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L166", "receiver": "_remote_rq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L167", "receiver": "_sq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L168", "receiver": "_new_rq_wrs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "callee": "clear", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L177", "receiver": "_sbuf", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "callee": "clear", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L178", "receiver": "_rbuf", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "callee": "clear", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L179", "receiver": "_rbuf_data", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reset", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L180", "receiver": "_read_butex", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readfromfd", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L192", "receiver": "_read_butex", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readfromfd", "callee": "milliseconds_from_now", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L193", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readfromfd", "callee": "fd", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L194", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readfromfd", "callee": "read", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L195", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readfromfd", "callee": "butex_wait", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L198", "receiver": "bthread", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pushbacktoreadbuf", "callee": "append", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L216", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "callee": "milliseconds_from_now", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L223", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "callee": "fd", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L224", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "callee": "write", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L225", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "callee": "WaitEpollOut", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L228", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_makelocalparsedhello", "callee": "GetUrmaRecvBlockSize", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L241", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_makelocalparsedhello", "callee": "memcpy", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L246", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_makelocalparsedhello", "callee": "GetPoolSegFor", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L251", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_makelocalparsedhello", "callee": "memcpy", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L253", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov2", "callee": "MakeLocalParsedHello", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L267", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov2", "callee": "memcpy", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L272", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov2", "callee": "memcpy", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L275", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "MakeLocalParsedHello", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L284", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_buffer_size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L285", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_recv_buffer_cnt", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L286", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_jetty_id", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L287", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_eid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L288", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_uasid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L289", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_tp_type", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L290", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_seg_eid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L291", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_seg_uasid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L292", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_seg_va", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L293", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_seg_len", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L294", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_filllocalhellov3", "callee": "set_seg_token_id", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L295", "receiver": "out", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "callee": "append", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L300", "receiver": "packet", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "callee": "SerializeToString", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L302", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L303", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "callee": "HostToNet32", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L306", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L306", "receiver": "body", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "callee": "append", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L307", "receiver": "packet", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "callee": "append", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L308", "receiver": "packet", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writehellov3", "callee": "WriteToFd", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L309", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "callee": "empty", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L314", "receiver": "data", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "callee": "milliseconds_from_now", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L315", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "callee": "fd", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L316", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "callee": "cut_into_file_descriptor", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L317", "receiver": "data", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_writetofd", "callee": "WaitEpollOut", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L320", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "ReadFromFd", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L330", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "NetToHost32", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L331", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "ReadFromFd", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L334", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "ParseFromArray", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L336", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "data", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L336", "receiver": "body", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L336", "receiver": "body", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L339", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "eid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L339", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L339", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "seg_eid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L339", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "buffer_size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L340", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "recv_buffer_cnt", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L341", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "jetty_id", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L342", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "memcpy", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L343", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "data", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L343", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "eid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L343", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "uasid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L344", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "tp_type", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L345", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "memcpy", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L346", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "data", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L346", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "seg_eid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L346", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "seg_uasid", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L347", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "seg_va", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L348", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "seg_len", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L349", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "seg_token_id", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L350", "receiver": "msg", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_readandparsehellov3", "callee": "ValidHello", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L351", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "GetUrmaContext", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L362", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "BAIDU_SCOPED_LOCK", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L371", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "urma_create_jfce", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L385", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L388", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "urma_create_jfc", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L396", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "PLOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L397", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "urma_create_jfr", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L405", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "PLOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L406", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "GetUrmaMaxSge", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L414", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "urma_create_jetty", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L420", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "PLOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L421", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "resize", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L424", "receiver": "_sbuf", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "resize", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L425", "receiver": "_rbuf", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "resize", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L426", "receiver": "_rbuf_data", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L431", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "ReqNotifyCq", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L435", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "keytable_pool", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L440", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "Create", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L443", "receiver": "Socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "PLOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L444", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "keytable_pool", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L451", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "Create", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L453", "receiver": "Socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "PLOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L454", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_allocateresources", "callee": "PollerAddCqSid", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L457", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_deallocateresources", "callee": "PollerRemoveCqSid", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L466", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_deallocateresources", "callee": "Address", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L472", "receiver": "Socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_deallocateresources", "callee": "fd", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L473", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_deallocateresources", "callee": "RemoveConsumer", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L474", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_deallocateresources", "callee": "SetFailed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L478", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "callee": "GetUrmaContext", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L495", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "callee": "memcpy", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L502", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "callee": "urma_import_seg", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L512", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "callee": "PLOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L514", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "callee": "memcpy", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L520", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "callee": "urma_import_jetty", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L532", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_importpeer", "callee": "PLOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L534", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "callee": "_ref_num", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L560", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "callee": "_ref_at", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L561", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "callee": "fetch1", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L562", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "callee": "GetPoolSegFor", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L564", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "callee": "get_first_data_meta", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L567", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaiobuf_cut_into_sglist", "callee": "cutn", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L582", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "GetUrmaMaxSge", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L595", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "alloca", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L599", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L605", "receiver": "_remote_rq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L606", "receiver": "_sq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "GetUrmaRecvBlockSize", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L617", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "empty", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L621", "receiver": "data", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "memset", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L631", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "exchange", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L633", "receiver": "_new_rq_wrs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "urma_post_jetty_send_wr", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L642", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "fetch_add", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L644", "receiver": "_new_rq_wrs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L645", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "GetUrmaMaxSge", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L647", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L652", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L655", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "fetch_sub", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L657", "receiver": "_remote_rq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_cutfromiobuflist", "callee": "fetch_sub", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L658", "receiver": "_sq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_iswritable", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L665", "receiver": "_remote_rq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_iswritable", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L666", "receiver": "_sq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_dopostrecv", "callee": "GetPoolSegFor", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L674", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_dopostrecv", "callee": "urma_post_jfr_wr", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L681", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_postrecv", "callee": "GetUrmaRecvBlockSize", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L689", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_postrecv", "callee": "clear", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L691", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_postrecv", "callee": "Next", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L696", "receiver": "zcis", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_postrecv", "callee": "DoPostRecv", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L702", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_postrecv", "callee": "clear", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L705", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_postrecv", "callee": "Next", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L711", "receiver": "zcos", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_postrecv", "callee": "DoPostRecv", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L718", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendimm", "callee": "memset", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L735", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendimm", "callee": "urma_post_jetty_send_wr", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L743", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendimm", "callee": "fetch_add", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L744", "receiver": "_new_rq_wrs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendack", "callee": "fetch_add", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L753", "receiver": "_new_rq_wrs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendack", "callee": "SendImm", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L756", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_sendack", "callee": "exchange", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L756", "receiver": "_new_rq_wrs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L763", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L771", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L773", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "SendAck", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L782", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "clear", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L787", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "subtle::MemoryBarrier", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L790", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "fetch_add", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L791", "receiver": "_sq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L792", "receiver": "_remote_rq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "WakeAsEpollOut", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L794", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L801", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L807", "receiver": "_remote_rq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L810", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "compare_exchange_weak", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L814", "receiver": "_remote_rq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L820", "receiver": "_sq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "WakeAsEpollOut", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L821", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L824", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "GetUrmaRecvBlockSize", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L828", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L829", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "cutn", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L838", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "append", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L840", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "PostRecv", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L842", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_handlecompletion", "callee": "SendAck", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L843", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "user", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L848", "receiver": "m", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "Address", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L851", "receiver": "Socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "Failed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L852", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "WaitCqEvent", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L856", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "min<int>", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L866", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "urma_poll_jfc", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L868", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L874", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L876", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "Failed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L878", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "HandleCompletion", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L882", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "urma_ack_jfc", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L896", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "ReqNotifyCq", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L897", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "Failed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L902", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "SetFailed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L903", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "cpuwide_time_us", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L908", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "gettimeofday_us", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L909", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "user", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L910", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "ProcessNewMessage", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L913", "receiver": "messenger", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L913", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L915", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L918", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L920", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollcq", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L921", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_applyremotehello", "callee": "min<uint32_t>", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L934", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_applyremotehello", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L942", "receiver": "_remote_rq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_applyremotehello", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L944", "receiver": "_sq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L954", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "OnNewMessages", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L961", "receiver": "InputMessenger", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L967", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "CreatedByConnect", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L969", "receiver": "m", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "IsUrmaAvailable", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L971", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "OnNewMessages", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L974", "receiver": "InputMessenger", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "ReAddress", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L978", "receiver": "m", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "bthread_attr_set_name", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L982", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "bthread_start_background", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L983", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L986", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "release", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L988", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "fetch_add", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L996", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "butex_wake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L997", "receiver": "bthread", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "OnNewMessages", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1000", "receiver": "InputMessenger", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_onnewdatafromtcp", "callee": "MoreReadEvents", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1006", "receiver": "m", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_tryreadontcp", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1011", "receiver": "_state", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_tryreadontcp", "callee": "OnNewMessages", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1012", "receiver": "InputMessenger", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "callee": "read", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1020", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "callee": "fd", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1020", "receiver": "socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "callee": "SetFailed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1024", "receiver": "socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "callee": "berror", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1025", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "callee": "MoreReadEvents", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1028", "receiver": "socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "callee": "SetEOF", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1032", "receiver": "socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_tryreadontcpduringurmaest", "callee": "SetFailed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1035", "receiver": "socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_fallbacktotcp", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1044", "receiver": "_state", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_fallbacktotcp", "callee": "DeallocateResources", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1045", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_fallbacktotcp", "callee": "TryReadOnTcp", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1047", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1053", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "callee": "GetStateStr", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1053", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1054", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "callee": "berror", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1056", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1058", "receiver": "_state", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "callee": "DeallocateResources", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1059", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1061", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_failhandshake", "callee": "SetFailed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1065", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1075", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1076", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1077", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1078", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "IsUrmaAvailable", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1079", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "FallbackToTcp", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1080", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "AllocateResources", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1084", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "FallbackToTcp", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1085", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "PostRecv", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1089", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "FallbackToTcp", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1090", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1093", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1094", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "ProtocolVersion", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1097", "receiver": "hs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "SendLocalHello", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1098", "receiver": "hs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1100", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1103", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1104", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "ReceiveAndParseRemoteHello", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1108", "receiver": "hs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1110", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "FallbackToTcp", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1114", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1117", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1118", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "ApplyRemoteHello", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1119", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "ImportPeer", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1121", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1123", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1126", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1127", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "HostToNet32", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1130", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "WriteToFd", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1131", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1133", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1138", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatclient", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1140", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1147", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1148", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1149", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1150", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "ReadFromFd", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1153", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1155", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "PushBackToReadBuf", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1161", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FallbackToTcp", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1162", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "ProtocolVersion", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1165", "receiver": "hs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "ReceiveAndParseRemoteHello", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1168", "receiver": "hs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1170", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1174", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1177", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1178", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "AllocateResources", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1180", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1182", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "PostRecv", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1185", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1187", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1190", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1191", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "ApplyRemoteHello", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1192", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "ImportPeer", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1194", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1196", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1199", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1200", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "SendLocalHello", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1202", "receiver": "hs", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1204", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1207", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1208", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "ReadFromFd", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1211", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1213", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "NetToHost32", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1216", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1219", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FailHandshake", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1222", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1227", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1229", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_processhandshakeatserver", "callee": "FallbackToTcp", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1231", "receiver": "ep", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "callee": "Address", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1243", "receiver": "Socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1249", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "callee": "Run", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1251", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "callee": "IsUrmaAvailable", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1254", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "callee": "Run", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1260", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "callee": "bthread_attr_set_name", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1265", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "callee": "bthread_start_background", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1266", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "callee": "Run", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1271", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_startconnect", "callee": "release", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1275", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaconnect_run", "callee": "cb", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1285", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_getstatestr", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1294", "receiver": "_state", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_debuginfo", "callee": "GetStateStr", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1314", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_debuginfo", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1317", "receiver": "_sq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_debuginfo", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1318", "receiver": "_remote_rq_window_size", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "urma_wait_jfc", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1329", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "PLOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1335", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1336", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "SetFailed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1337", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "berror", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1338", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1343", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1343", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "SetFailed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1345", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "LOG_IF", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1348", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_waitcqevent", "callee": "description", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1349", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reqnotifycq", "callee": "urma_rearm_jfc", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1358", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reqnotifycq", "callee": "PLOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1361", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reqnotifycq", "callee": "SetFailed", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1362", "receiver": "_socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_reqnotifycq", "callee": "berror", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1362", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1374", "receiver": "_poller_groups", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "empty", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1375", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "compare_exchange_strong", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1381", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "init_fn", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1396", "receiver": "poller", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "load", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1398", "receiver": "running", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "Dequeue", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1399", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "emplace", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1401", "receiver": "cq_sids", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "erase", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1403", "receiver": "cq_sids", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "Address", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1408", "receiver": "Socket", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "PollCq", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1409", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1409", "receiver": "s", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "callback", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1413", "receiver": "poller", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "empty", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1415", "receiver": "cq_sids", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "bthread_yield", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1416", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "release_fn", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1420", "receiver": "poller", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1426", "receiver": "pollers", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1433", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "bthread_join", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1435", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "bthread_attr_set_name", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1445", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "bthread_start_background", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1446", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "get", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1447", "receiver": "args", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1449", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "bthread_join", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1451", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmodeinitialize", "callee": "release", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1457", "receiver": "args", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmoderelease", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1463", "receiver": "_poller_groups", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmoderelease", "callee": "store", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1467", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollingmoderelease", "callee": "bthread_join", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1470", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_polleraddcqsid", "callee": "empty", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1477", "receiver": "_poller_groups", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_polleraddcqsid", "callee": "bthread_self_tag", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1480", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_polleraddcqsid", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1481", "receiver": "_poller_groups", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_polleraddcqsid", "callee": "empty", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1485", "receiver": "pollers", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_polleraddcqsid", "callee": "fmix32", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1487", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_polleraddcqsid", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1487", "receiver": "pollers", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_polleraddcqsid", "callee": "Enqueue", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1488", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollerremovecqsid", "callee": "empty", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1493", "receiver": "_poller_groups", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollerremovecqsid", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1494", "receiver": "_poller_groups", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollerremovecqsid", "callee": "empty", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1498", "receiver": "pollers", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollerremovecqsid", "callee": "fmix32", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1500", "receiver": "butil", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollerremovecqsid", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1500", "receiver": "pollers", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_pollerremovecqsid", "callee": "Enqueue", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1501", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "empty", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1508", "receiver": "_poller_groups", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1510", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "vector<PollerGroup>", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1516", "receiver": "std", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "GetUrmaContext", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1519", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "urma_create_jfce", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1525", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "urma_create_jfc", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1534", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "urma_create_jfr", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1542", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "GetUrmaMaxSge", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1550", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "urma_create_jetty", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1556", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalinitialize", "callee": "LOG", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1562", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalrelease", "callee": "BAIDU_SCOPED_LOCK", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1568", "receiver": null, "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalrelease", "callee": "size", "is_member_call": true, "source_file": "urma_endpoint.cpp", "source_location": "L1576", "receiver": "_poller_groups", "lang": "cpp"}, {"caller_nid": "c_workspace_code_opensource_brpc_src_brpc_urma_urma_endpoint_urmaendpoint_globalrelease", "callee": "PollingModeRelease", "is_member_call": false, "source_file": "urma_endpoint.cpp", "source_location": "L1577", "receiver": null, "lang": "cpp"}], "cpp_type_table": {"path": "C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp", "table": {"p": "ParsedHello", "packet": "IOBuf", "msg": "UrmaHello", "options": "SocketOptions", "next": "UrmaResource", "s": "SocketUniquePtr", "r": "BlockRef", "to": "IOBuf", "zcos": "IOBufAsZeroCopyOutputStream", "zcis": "IOBufAsZeroCopyOutputStream", "last_msg": "InputMessageClosure", "state": "State", "ep": "UrmaEndpoint", "remote": "ParsedHello", "guard": "RunGuard"}}}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/f822344e09f50ff082a2ebbaa0f37defc274c585af039c0e7b995bfe7f0bf804.json b/src/brpc/urma/graphify-out/cache/ast/v0.9.23/f822344e09f50ff082a2ebbaa0f37defc274c585af039c0e7b995bfe7f0bf804.json
deleted file mode 100644
index fa3caa7fdb..0000000000
--- a/src/brpc/urma/graphify-out/cache/ast/v0.9.23/f822344e09f50ff082a2ebbaa0f37defc274c585af039c0e7b995bfe7f0bf804.json
+++ /dev/null
@@ -1 +0,0 @@
-{"nodes": [{"id": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_api_h", "label": "urma_api.h", "file_type": "code", "source_file": "sdk/urma/urma_api.h", "source_location": "L1"}], "edges": [{"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_api_h", "target": "stdbool", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_api.h", "source_location": "L13", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_api_h", "target": "stdint", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_api.h", "source_location": "L14", "weight": 1.0}, {"source": "c_workspace_code_opensource_brpc_src_brpc_urma_sdk_urma_urma_api_h", "target": "urma_types", "relation": "imports", "context": "import", "confidence": "EXTRACTED", "source_file": "sdk/urma/urma_api.h", "source_location": "L16", "weight": 1.0}], "raw_calls": []}
\ No newline at end of file
diff --git a/src/brpc/urma/graphify-out/cache/stat-index.json b/src/brpc/urma/graphify-out/cache/stat-index.json
deleted file mode 100644
index 6e429df537..0000000000
--- a/src/brpc/urma/graphify-out/cache/stat-index.json
+++ /dev/null
@@ -1 +0,0 @@
-{"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\mock_urma.cpp":{"size":22422,"mtime_ns":1785291503405746700,"word_count":2055,"hashes":{"mock_urma.cpp":"608feeb18131c6633a1d3bae5ce1bdaf944a337cafc10e12152fa2915751f7d0"}},"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_api.h":{"size":47786,"mtime_ns":1785227626464076200,"word_count":6750,"hashes":{"sdk/urma/urma_api.h":"f822344e09f50ff082a2ebbaa0f37defc274c585af039c0e7b995bfe7f0bf804"}},"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_opcode.h":{"size":10591,"mtime_ns":1785226861704155300,"word_count":1138,"hashes":{"sdk/urma/urma_opcode.h":"01ccfd37e3d64cd110462f1203e0d20642510e3e3d14a570a041257996772a31"}},"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\sdk\\urma\\urma_types.h":{"size":54318,"mtime_ns":1785227626506547800,"word_count":6079,"hashes":{"sdk/urma/urma_types.h":"6870b34881c2bda6a7406307467705c41b2381b7a5af286fab00d3241d6a5eca"}},"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.cpp":{"size":58559,"mtime_ns":1785309099990290300,"word_count":5389,"hashes":{"urma_endpoint.cpp":"bb7775d86173e02925fc786db010956f4dd08aef5a92ffdbffd70a11effd1833"}},"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_endpoint.h":{"size":13432,"mtime_ns":1785309036527955400,"word_count":1577,"hashes":{"urma_endpoint.h":"7899e48f9378edf160c448d2d8eb8cdaa14683461e3f2562a4ce8dedce8721ed"}},"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_handshake.cpp":{"size":11297,"mtime_ns":1785291857383725700,"word_count":1138,"hashes":{"urma_handshake.cpp":"3dcbdee4a792ca85149ae0eada9ea3f39bb1c3f972074cfdeb983ed964bc1f54"}},"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_handshake.h":{"size":6762,"mtime_ns":1785291144209111300,"word_count":893,"hashes":{"urma_handshake.h":"9ead6eae6b7ea7f4b18e3757e1e7d33a73a6879dca40078e12765880de1061a1"}},"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.cpp":{"size":24053,"mtime_ns":1785307850782229900,"word_count":2487,"hashes":{"urma_helper.cpp":"5af18e30c1f05aae06e4f45bf09d4d6ab3654daf64631c4821071a362adf2f1e"}},"C:\\workspace\\code\\opensource\\brpc\\src\\brpc\\urma\\urma_helper.h":{"size":3392,"mtime_ns":1785290825559803600,"word_count":452,"hashes":{"urma_helper.h":"1df09f4812201fd3151eb13e804615a74b896364be016d8a28ec657f714e1422"}}}
\ No newline at end of file