1
发送端:
2
  应用缓冲区 → [CPU 拷贝] → 内核 socket 缓冲区 → [协议栈封装] → sk_buff
3
  → [CPU 拷贝到 DMA 映射区] → NIC DMA 读取 → 网络发送
4

5
接收端:
6
  NIC DMA 写入 → [中断通知 CPU] → 内核协议栈解析 → [CPU 拷贝] → 应用缓冲区

1
发送端:
2
  应用缓冲区（已注册 MR）→ NIC 直接 DMA 读取 → 网络发送
3

4
接收端:
5
  NIC DMA 直接写入应用缓冲区（已注册 MR）→ 完成 CQE 通知

1
// 创建 Protection Domain
2
struct ibv_pd *pd = ibv_alloc_pd(context);
3
if (!pd) {
4
    perror("ibv_alloc_pd");
5
    exit(1);
6
}
7

8
// 释放 Protection Domain
9
ibv_dealloc_pd(pd);

1
// 注册 Memory Region
2
void *buf = malloc(BUFFER_SIZE);
3
struct ibv_mr *mr = ibv_reg_mr(pd, buf, BUFFER_SIZE,
4
                                IBV_ACCESS_LOCAL_WRITE  |   // 本地写权限
5
                                IBV_ACCESS_REMOTE_WRITE |   // 远端写权限
6
                                IBV_ACCESS_REMOTE_READ  |   // 远端读权限
7
                                IBV_ACCESS_REMOTE_ATOMIC);  // 远端原子操作权限
8
if (!mr) {
9
    perror("ibv_reg_mr");
10
    exit(1);
11
}
12

13
// mr 包含两个关键密钥：
14
// mr->lkey — 本地访问密钥（Local Key），提交 Work Request 时使用
15
// mr->rkey — 远程访问密钥（Remote Key），远端进行 RDMA 操作时使用
16

17
printf("lkey: 0x%x, rkey: 0x%x\n", mr->lkey, mr->rkey);
18

19
// 注销 Memory Region
20
ibv_dereg_mr(mr);

1
// 创建 Queue Pair
2
struct ibv_qp_init_attr qp_init_attr = {
3
    .send_cq = cq,          // 发送完成队列
4
    .recv_cq = cq,          // 接收完成队列（可与 send_cq 相同）
5
    .qp_type = IBV_QPT_RC,  // 可靠连接（Reliable Connection）
6
    .cap = {
7
        .max_send_wr  = 256,   // Send Queue 最大 Work Request 数
8
        .max_recv_wr  = 256,   // Receive Queue 最大 Work Request 数
9
        .max_send_sge = 4,     // 每个 Send WR 最大 Scatter/Gather Element 数
10
        .max_recv_sge = 4,     // 每个 Recv WR 最大 Scatter/Gather Element 数
11
        .max_inline_data = 64, // 内联数据最大字节数
12
    },
13
    .sq_sig_all = 0,         // 仅在 WR 中指定时才产生完成通知
14
};
15

16
struct ibv_qp *qp = ibv_create_qp(pd, &qp_init_attr);
17
if (!qp) {
18
    perror("ibv_create_qp");
19
    exit(1);
20
}

1
// 创建 Completion Queue
2
struct ibv_cq *cq = ibv_create_cq(context, 256, NULL, NULL, 0);
3
if (!cq) {
4
    perror("ibv_create_cq");
5
    exit(1);
6
}
7

8
// 轮询 CQ 获取完成通知
9
struct ibv_wc wc;
10
int ne = ibv_poll_cq(cq, 1, &wc);
11
if (ne > 0) {
12
    if (wc.status != IBV_WC_SUCCESS) {
13
        fprintf(stderr, "完成状态错误: %s\n", ibv_wc_status_str(wc.status));
14
    } else {
15
        printf("WR 完成，opcode: %d, byte_len: %u\n", wc.opcode, wc.byte_len);
16
        // wc.wr_id 是提交 WR 时设置的用户自定义标识
17
    }
18
}
19

20
// 也可以使用完成通道（Completion Channel）实现事件驱动
21
struct ibv_comp_channel *channel = ibv_create_comp_channel(context);
22
struct ibv_cq *cq = ibv_create_cq(context, 256, NULL, channel, 0);
23

24
// 请求完成通知
25
ibv_req_notify_cq(cq, 0);
26

27
// 等待完成事件
28
struct ibv_cq *ev_cq;
29
void *ev_ctx;
30
ibv_get_cq_event(channel, &ev_cq, &ev_ctx);
31

32
// 处理完成后需要重新请求通知
33
ibv_ack_cq_events(ev_cq, 1);
34
ibv_req_notify_cq(cq, 0);

1
// 创建 Shared Receive Queue
2
struct ibv_srq_init_attr srq_init_attr = {
3
    .attr = {
4
        .max_wr  = 1024,   // 最大 Receive WR 数
5
        .max_sge = 4,      // 每个 WR 最大 SGE 数
6
        .srq_limit = 16,   // 低水位线，触发事件通知
7
    },
8
};
9

10
struct ibv_srq *srq = ibv_create_srq(pd, &srq_init_attr);
11

12
// 向 SRQ 投递 Receive WR
13
struct ibv_recv_wr wr, *bad_wr;
14
struct ibv_sge sge;
15

16
sge.addr   = (uintptr_t)buf;
17
sge.length = BUFFER_SIZE;
18
sge.lkey   = mr->lkey;
19

20
wr.next   = NULL;
21
wr.wr_id  = 1;
22
wr.sg_list = &sge;
23
wr.num_sge = 1;
24

25
ibv_post_srq_recv(srq, &wr, &bad_wr);
26

27
// 创建 QP 时关联 SRQ
28
struct ibv_qp_init_attr qp_init_attr = {
29
    .srq = srq,   // 关联 SRQ，QP 不再使用自己的 RQ
30
    // ... 其他属性
31
};

1
// RESET → INIT
2
struct ibv_qp_attr attr;
3
memset(&attr, 0, sizeof(attr));
4
attr.qp_state   = IBV_QPS_INIT;
5
attr.port_num   = 1;                    // 物理端口编号
6
attr.pkey_index = 0;                    // PKey 索引
7
attr.qp_access_flags = IBV_ACCESS_REMOTE_WRITE |
8
                       IBV_ACCESS_REMOTE_READ  |
9
                       IBV_ACCESS_REMOTE_ATOMIC;
10

11
if (ibv_modify_qp(qp, &attr,
12
                   IBV_QP_STATE      |
13
                   IBV_QP_PKEY_INDEX |
14
                   IBV_QP_PORT       |
15
                   IBV_QP_ACCESS_FLAGS)) {
16
    fprintf(stderr, "RESET → INIT 失败\n");
17
    exit(1);
18
}
19

20
// INIT → RTR
21
memset(&attr, 0, sizeof(attr));
22
attr.qp_state           = IBV_QPS_RTR;
23
attr.path_mtu           = IBV_MTU_4096;       // 路径 MTU
24
attr.dest_qp_num        = remote_qpn;          // 远端 QP 号
25
attr.rq_psn             = 0;                   // 接收端起始 PSN
26
attr.max_dest_rd_atomic = 1;                   // 远端可接受的未完成 RDMA Read/Atomic 数
27
attr.min_rnr_timer      = 12;                  // RNR (Receiver Not Ready) 定时器
28

29
// RoCEv2 需要设置 Global Routing 信息
30
attr.ah_attr.is_global  = 1;
31
attr.ah_attr.dlid       = remote_lid;          // 远端 LID
32
attr.ah_attr.sl         = 0;                   // Service Level
33
attr.ah_attr.src_path_bits = 0;
34
attr.ah_attr.port_num   = 1;
35
attr.ah_attr.grh.dgid   = remote_gid;          // 远端 GID
36
attr.ah_attr.grh.sgid_index = 0;               // 本地 GID 索引
37
attr.ah_attr.grh.hop_limit  = 64;
38

39
if (ibv_modify_qp(qp, &attr,
40
                   IBV_QP_STATE              |
41
                   IBV_QP_AV                 |
42
                   IBV_QP_PATH_MTU           |
43
                   IBV_QP_DEST_QPN           |
44
                   IBV_QP_RQ_PSN             |
45
                   IBV_QP_MAX_DEST_RD_ATOMIC |
46
                   IBV_QP_MIN_RNR_TIMER)) {
47
    fprintf(stderr, "INIT → RTR 失败\n");
48
    exit(1);
49
}
50

51
// RTR → RTS
52
memset(&attr, 0, sizeof(attr));
53
attr.qp_state      = IBV_QPS_RTS;
54
attr.timeout       = 14;    // 重传超时（4.096μs × 2^14 ≈ 67ms）
55
attr.retry_cnt     = 7;     // 重传次数
56
attr.rnr_retry     = 7;     // RNR 重试次数
57
attr.sq_psn        = 0;     // 发送端起始 PSN
58
attr.max_rd_atomic = 1;     // 本端可发出的未完成 RDMA Read/Atomic 数
59

60
if (ibv_modify_qp(qp, &attr,
61
                   IBV_QP_STATE     |
62
                   IBV_QP_TIMEOUT   |
63
                   IBV_QP_RETRY_CNT |
64
                   IBV_QP_RNR_RETRY |
65
                   IBV_QP_SQ_PSN    |
66
                   IBV_QP_MAX_QP_RD_ATOMIC)) {
67
    fprintf(stderr, "RTR → RTS 失败\n");
68
    exit(1);
69
}

1
#include <rdma/rdma_cma.h>
2
#include <stdio.h>
3
#include <stdlib.h>
4
#include <string.h>
5

6
#define BUFFER_SIZE 4096
7

8
struct context {
9
    struct ibv_pd  *pd;
10
    struct ibv_mr  *mr;
11
    struct ibv_cq  *cq;
12
    struct ibv_qp  *qp;
13
    char           *buf;
14
};
15

16
int main(int argc, char **argv)
17
{
18
    struct rdma_cm_id *listen_id, *conn_id;
19
    struct rdma_event_channel *ec;
20
    struct rdma_cm_event *event;
21
    struct context ctx;
22

23
    // 1. 创建事件通道和监听 ID
24
    ec = rdma_create_event_channel();
25
    rdma_create_id(ec, &listen_id, NULL, RDMA_PS_TCP);
26

27
    // 2. 绑定地址并监听
28
    struct sockaddr_in addr;
29
    memset(&addr, 0, sizeof(addr));
30
    addr.sin_family      = AF_INET;
31
    addr.sin_port        = htons(18515);  // 监听端口
32
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
33

34
    rdma_bind_addr(listen_id, (struct sockaddr *)&addr);
35
    rdma_listen(listen_id, 1);
36
    printf("服务端监听端口 %d\n", 18515);
37

38
    // 3. 等待连接请求
39
    rdma_get_cm_event(ec, &event);
40
    if (event->event != RDMA_CM_EVENT_CONNECT_REQUEST) {
41
        fprintf(stderr, "意外事件: %s\n", rdma_event_str(event->event));
42
        exit(1);
43
    }
44
    conn_id = event->id;
45
    rdma_ack_cm_event(event);
46

47
    // 4. 在新连接上创建 PD、MR、CQ、QP
48
    ctx.pd  = ibv_alloc_pd(conn_id->verbs);
49
    ctx.buf = malloc(BUFFER_SIZE);
50
    ctx.mr  = ibv_reg_mr(ctx.pd, ctx.buf, BUFFER_SIZE,
51
                          IBV_ACCESS_LOCAL_WRITE  |
52
                          IBV_ACCESS_REMOTE_WRITE |
53
                          IBV_ACCESS_REMOTE_READ);
54
    ctx.cq  = ibv_create_cq(conn_id->verbs, 16, NULL, NULL, 0);
55

56
    struct ibv_qp_init_attr qp_attr;
57
    memset(&qp_attr, 0, sizeof(qp_attr));
58
    qp_attr.send_cq = ctx.cq;
59
    qp_attr.recv_cq = ctx.cq;
60
    qp_attr.qp_type = IBV_QPT_RC;
61
    qp_attr.cap.max_send_wr  = 16;
62
    qp_attr.cap.max_recv_wr  = 16;
63
    qp_attr.cap.max_send_sge = 1;
64
    qp_attr.cap.max_recv_sge = 1;
65

66
    // RDMA CM 自动处理 QP 创建和状态转换
67
    rdma_create_qp(conn_id, ctx.pd, &qp_attr);
68
    ctx.qp = conn_id->qp;
69

70
    // 5. 接受连接
71
    struct rdma_conn_param conn_param;
72
    memset(&conn_param, 0, sizeof(conn_param));
73
    conn_param.private_data     = &ctx.mr->rkey;  // 可传递私有数据
74
    conn_param.private_data_len = sizeof(ctx.mr->rkey);
75
    rdma_accept(conn_id, &conn_param);
76

77
    // 6. 等待建立完成
78
    rdma_get_cm_event(ec, &event);
79
    rdma_ack_cm_event(event);
80

81
    printf("连接建立成功！\n");
82

83
    // ... 数据传输 ...
84

85
    // 7. 清理
86
    rdma_disconnect(conn_id);
87
    ibv_destroy_qp(ctx.qp);
88
    ibv_dereg_mr(ctx.mr);
89
    ibv_destroy_cq(ctx.cq);
90
    ibv_dealloc_pd(ctx.pd);
91
    free(ctx.buf);
92
    rdma_destroy_id(conn_id);
93
    rdma_destroy_id(listen_id);
94
    rdma_destroy_event_channel(ec);
95

96
    return 0;
97
}

1
#include <rdma/rdma_cma.h>
2
#include <stdio.h>
3
#include <stdlib.h>
4
#include <string.h>
5

6
#define BUFFER_SIZE 4096
7

8
int main(int argc, char **argv)
9
{
10
    struct rdma_cm_id *conn_id;
11
    struct rdma_event_channel *ec;
12
    struct rdma_cm_event *event;
13

14
    // 1. 创建事件通道和连接 ID
15
    ec = rdma_create_event_channel();
16
    rdma_create_id(ec, &conn_id, NULL, RDMA_PS_TCP);
17

18
    // 2. 解析服务端地址并连接
19
    struct sockaddr_in addr;
20
    memset(&addr, 0, sizeof(addr));
21
    addr.sin_family = AF_INET;
22
    addr.sin_port   = htons(18515);
23
    inet_pton(AF_INET, argv[1], &addr.sin_addr);
24

25
    rdma_resolve_addr(conn_id, NULL, (struct sockaddr *)&addr, 2000);
26

27
    // 3. 等待地址解析完成
28
    rdma_get_cm_event(ec, &event);
29
    rdma_ack_cm_event(event);
30

31
    // 4. 等待路由解析完成
32
    rdma_get_cm_event(ec, &event);
33
    rdma_ack_cm_event(event);
34

35
    // 5. 创建 PD、MR、CQ、QP（与服务端类似）
36
    struct ibv_pd *pd  = ibv_alloc_pd(conn_id->verbs);
37
    char *buf = malloc(BUFFER_SIZE);
38
    struct ibv_mr *mr = ibv_reg_mr(pd, buf, BUFFER_SIZE,
39
                                    IBV_ACCESS_LOCAL_WRITE  |
40
                                    IBV_ACCESS_REMOTE_WRITE |
41
                                    IBV_ACCESS_REMOTE_READ);
42
    struct ibv_cq *cq = ibv_create_cq(conn_id->verbs, 16, NULL, NULL, 0);
43

44
    struct ibv_qp_init_attr qp_attr;
45
    memset(&qp_attr, 0, sizeof(qp_attr));
46
    qp_attr.send_cq = cq;
47
    qp_attr.recv_cq = cq;
48
    qp_attr.qp_type = IBV_QPT_RC;
49
    qp_attr.cap.max_send_wr  = 16;
50
    qp_attr.cap.max_recv_wr  = 16;
51
    qp_attr.cap.max_send_sge = 1;
52
    qp_attr.cap.max_recv_sge = 1;
53

54
    rdma_create_qp(conn_id, pd, &qp_attr);
55

56
    // 6. 发起连接
57
    struct rdma_conn_param conn_param;
58
    memset(&conn_param, 0, sizeof(conn_param));
59
    rdma_connect(conn_id, &conn_param);
60

61
    // 7. 等待连接建立
62
    rdma_get_cm_event(ec, &event);
63
    if (event->event != RDMA_CM_EVENT_ESTABLISHED) {
64
        fprintf(stderr, "连接失败: %s\n", rdma_event_str(event->event));
65
        exit(1);
66
    }
67
    rdma_ack_cm_event(event);
68

69
    printf("连接建立成功！\n");
70

71
    // ... 数据传输 ...
72

73
    // 8. 清理
74
    rdma_disconnect(conn_id);
75
    rdma_destroy_qp(conn_id);
76
    ibv_dereg_mr(mr);
77
    ibv_destroy_cq(cq);
78
    ibv_dealloc_pd(pd);
79
    free(buf);
80
    rdma_destroy_id(conn_id);
81
    rdma_destroy_event_channel(ec);
82

83
    return 0;
84
}

1
// 接收端：预先 Post Receive
2
struct ibv_recv_wr recv_wr, *bad_recv_wr;
3
struct ibv_sge recv_sge;
4

5
recv_sge.addr   = (uintptr_t)recv_buf;
6
recv_sge.length = BUFFER_SIZE;
7
recv_sge.lkey   = recv_mr->lkey;
8

9
recv_wr.wr_id   = 1;
10
recv_wr.next    = NULL;
11
recv_wr.sg_list = &recv_sge;
12
recv_wr.num_sge = 1;
13

14
ibv_post_recv(qp, &recv_wr, &bad_recv_wr);
15

16
// 发送端：Post Send
17
struct ibv_send_wr send_wr, *bad_send_wr;
18
struct ibv_sge send_sge;
19

20
send_sge.addr   = (uintptr_t)send_buf;
21
send_sge.length = msg_size;
22
send_sge.lkey   = send_mr->lkey;
23

24
send_wr.wr_id      = 2;
25
send_wr.next       = NULL;
26
send_wr.sg_list    = &send_sge;
27
send_wr.num_sge    = 1;
28
send_wr.opcode     = IBV_WR_SEND;
29
send_wr.send_flags = IBV_SEND_SIGNALED;  // 请求完成通知
30

31
ibv_post_send(qp, &send_wr, &bad_send_wr);

1
// RDMA Write 示例
2
// 前提：已通过连接建立交换了远端的 rkey 和远程地址
3

4
struct ibv_send_wr wr, *bad_wr;
5
struct ibv_sge sge;
6

7
// 本地数据源
8
sge.addr   = (uintptr_t)local_buf;    // 本地 MR 缓冲区地址
9
sge.length = data_len;                 // 要写入的数据长度
10
sge.lkey   = local_mr->lkey;          // 本地 MR 的 lkey
11

12
memset(&wr, 0, sizeof(wr));
13
wr.wr_id                  = 100;
14
wr.next                   = NULL;
15
wr.sg_list                = &sge;
16
wr.num_sge                = 1;
17
wr.opcode                 = IBV_WR_RDMA_WRITE;   // RDMA Write 操作
18
wr.send_flags             = IBV_SEND_SIGNALED;
19
wr.wr.rdma.remote_addr    = remote_addr;          // 远端内存地址
20
wr.wr.rdma.rkey           = remote_rkey;          // 远端 MR 的 rkey
21

22
if (ibv_post_send(qp, &wr, &bad_wr)) {
23
    fprintf(stderr, "RDMA Write 提交失败\n");
24
    exit(1);
25
}
26

27
// 等待完成
28
struct ibv_wc wc;
29
while (ibv_poll_cq(cq, 1, &wc) == 0);
30
if (wc.status != IBV_WC_SUCCESS) {
31
    fprintf(stderr, "RDMA Write 失败: %s\n", ibv_wc_status_str(wc.status));
32
}

1
wr.opcode                 = IBV_WR_RDMA_WRITE_WITH_IMM;
2
wr.imm_data               = htonl(0x12345678);  // 4 字节立即数
3
// 其余字段与 RDMA Write 相同

1
// RDMA Read 示例
2
struct ibv_send_wr wr, *bad_wr;
3
struct ibv_sge sge;
4

5
// 本地目标缓冲区（数据将读到这里）
6
sge.addr   = (uintptr_t)local_buf;    // 本地 MR 缓冲区地址
7
sge.length = data_len;                 // 要读取的数据长度
8
sge.lkey   = local_mr->lkey;          // 本地 MR 的 lkey
9

10
memset(&wr, 0, sizeof(wr));
11
wr.wr_id                  = 200;
12
wr.next                   = NULL;
13
wr.sg_list                = &sge;
14
wr.num_sge                = 1;
15
wr.opcode                 = IBV_WR_RDMA_READ;    // RDMA Read 操作
16
wr.send_flags             = IBV_SEND_SIGNALED;
17
wr.wr.rdma.remote_addr    = remote_addr;          // 远端内存地址
18
wr.wr.rdma.rkey           = remote_rkey;          // 远端 MR 的 rkey
19

20
if (ibv_post_send(qp, &wr, &bad_wr)) {
21
    fprintf(stderr, "RDMA Read 提交失败\n");
22
    exit(1);
23
}
24

25
// 等待完成
26
struct ibv_wc wc;
27
while (ibv_poll_cq(cq, 1, &wc) == 0);
28
if (wc.status != IBV_WC_SUCCESS) {
29
    fprintf(stderr, "RDMA Read 失败: %s\n", ibv_wc_status_str(wc.status));
30
}
31

32
printf("成功从远端读取 %u 字节\n", wc.byte_len);

1
// Compare and Swap (CAS)
2
struct ibv_send_wr wr, *bad_wr;
3
struct ibv_sge sge;
4

5
sge.addr   = (uintptr_t)&local_result;  // 存放 CAS 返回的原始值
6
sge.length = sizeof(uint64_t);
7
sge.lkey   = local_mr->lkey;
8

9
memset(&wr, 0, sizeof(wr));
10
wr.wr_id                    = 300;
11
wr.next                     = NULL;
12
wr.sg_list                  = &sge;
13
wr.num_sge                  = 1;
14
wr.opcode                   = IBV_WR_ATOMIC_CMP_AND_SWP;
15
wr.send_flags               = IBV_SEND_SIGNALED;
16
wr.wr.atomic.remote_addr    = remote_addr;
17
wr.wr.atomic.rkey           = remote_rkey;
18
wr.wr.atomic.compare_add    = expected_value;   // 期望值
19
wr.wr.atomic.swap           = new_value;         // 新值
20

21
ibv_post_send(qp, &wr, &bad_wr);
22

23
// Fetch and Add
24
memset(&wr, 0, sizeof(wr));
25
wr.wr_id                    = 301;
26
wr.next                     = NULL;
27
wr.sg_list                  = &sge;
28
wr.num_sge                  = 1;
29
wr.opcode                   = IBV_WR_ATOMIC_FETCH_AND_ADD;
30
wr.send_flags               = IBV_SEND_SIGNALED;
31
wr.wr.atomic.remote_addr    = remote_addr;
32
wr.wr.atomic.rkey           = remote_rkey;
33
wr.wr.atomic.compare_add    = increment;         // 增量值
34

35
ibv_post_send(qp, &wr, &bad_wr);

1
# 分配 Huge Pages
2
echo 1024 > /proc/sys/vm/nr_hugepages   # 分配 1024 个 2MB Huge Pages
3

4
# 查看 Huge Pages 状态
5
cat /proc/meminfo | grep Huge
6

7
# 在程序中使用 Huge Pages
8
# 方式一：通过环境变量
9
export RDMAV_HUGEPAGES_SAFE=1
10

11
# 方式二：使用 mmap 分配 Huge Pages
12
void *buf = mmap(NULL, size, PROT_READ | PROT_WRITE,
13
                 MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB, -1, 0);

1
# 查看 RNIC 的 NUMA 节点
2
cat /sys/class/infiniband/mlx5_0/device/numa_node
3

4
# 将进程绑定到 RNIC 所在的 NUMA 节点
5
numactl --cpunodebind=0 --membind=0 ./rdma_app
6

7
# 查看 CPU 与 NUMA 节点的拓扑
8
numactl --hardware
9
lscpu | grep NUMA

1
// 创建 QP 时设置 inline data 大小
2
qp_init_attr.cap.max_inline_data = 64;
3

4
// 提交 WR 时使用 inline 标志
5
wr.send_flags |= IBV_SEND_INLINE;
6
// 此时 sge.addr 指向的数据会被直接复制到 WQE 中
7
// 不需要 MR，不需要 DMA 读取

1
// 链式提交多个 WR
2
struct ibv_send_wr wr1, wr2, wr3, *bad_wr;
3

4
// 设置 wr1, wr2, wr3 ...
5

6
wr1.next = &wr2;
7
wr2.next = &wr3;
8
wr3.next = NULL;
9

10
// 一次 ibv_post_send 提交 3 个 WR
11
// 只产生一次 Doorbell（一次 MMIO 写入）
12
ibv_post_send(qp, &wr1, &bad_wr);

1
# 调整 CQ 轮询批量大小
2
# 每次轮询处理多个 CQE，减少系统调用次数
3
int ne = ibv_poll_cq(cq, 32, wc_array);  // 一次轮询最多 32 个
4

5
# 调整 QP 深度
6
# 增大 max_send_wr / max_recv_wr 允许更多在途请求
7
qp_init_attr.cap.max_send_wr = 1024;
8
qp_init_attr.cap.max_recv_wr = 1024;
9

10
# 启用自适应轮询
11
# 在低负载时退避，高负载时积极轮询
12
# 需要应用层实现

1
# 查看系统中的 RDMA 设备
2
ibv_devinfo
3

4
# 输出示例：
5
# hca_id: mlx5_0
6
#   transport:          InfiniBand (0)
7
#   fw_ver:             28.39.3000
8
#   node_guid:          506b:4b03:00e8:7a40
9
#   sys_image_guid:     506b:4b03:00e8:7a43
10
#   vendor_id:          0x02c9
11
#   vendor_part_id:     4123
12
#   hw_ver:             0x0
13
#   board_id:           MT_0000000012
14
#   phys_port_cnt:      1
15
#     port:   1
16
#       state:              PORT_ACTIVE (4)
17
#       max_mtu:            4096 (5)
18
#       active_mtu:         4096 (5)
19
#       sm_lid:             1
20
#       port_lid:           2
21
#       port_lmc:           0x00
22
#       link_layer:         InfiniBand
23

24
# 查看特定设备的端口状态
25
ibv_devinfo -d mlx5_0 -i 1
26

27
# 查看 GID 表（RoCEv2 需要）
28
show_gids
29

30
# 列出所有 RDMA 设备
31
ibv_devices

1
# 服务端（在一台机器上运行）
2
rping -s -a 0.0.0.0 -p 18515 -v
3

4
# 客户端（在另一台机器上运行）
5
rping -c -a <server_ip> -p 18515 -v -C 10
6

7
# 输出示例：
8
# rdma_ping: data 32 bytes 1 trips 10 ms
9
# rdma_ping: data 64 bytes 1 trips 10 ms
10
# rdma_ping: data 256 bytes 1 trips 10 ms
11
# rdma_ping: data 1024 bytes 1 trips 10 ms
12
# ...
13

14
# 使用 RDMA CM 测试（RoCEv2）
15
# 服务端
16
rping -s -a <server_ip> -p 18515 -v
17

18
# 客户端
19
rping -c -a <server_ip> -p 18515 -v

1
#include <infiniband/verbs.h>
2
#include <stdio.h>
3
#include <stdlib.h>
4
#include <string.h>
5

6
#define BUF_SIZE 4096
7

8
int main()
9
{
10
    // 1. 获取设备列表
11
    int num_devices;
12
    struct ibv_device **dev_list = ibv_get_device_list(&num_devices);
13
    if (!dev_list || num_devices == 0) {
14
        fprintf(stderr, "未找到 RDMA 设备\n");
15
        return 1;
16
    }
17

18
    // 2. 打开设备
19
    struct ibv_context *ctx = ibv_open_device(dev_list[0]);
20
    if (!ctx) {
21
        fprintf(stderr, "打开设备失败\n");
22
        return 1;
23
    }
24

25
    // 3. 创建 PD
26
    struct ibv_pd *pd = ibv_alloc_pd(ctx);
27

28
    // 4. 注册 MR
29
    char *buf = malloc(BUF_SIZE);
30
    struct ibv_mr *mr = ibv_reg_mr(pd, buf, BUF_SIZE,
31
                                    IBV_ACCESS_LOCAL_WRITE  |
32
                                    IBV_ACCESS_REMOTE_WRITE |
33
                                    IBV_ACCESS_REMOTE_READ);
34
    printf("MR 注册成功: lkey=0x%x, rkey=0x%x\n", mr->lkey, mr->rkey);
35

36
    // 5. 创建 CQ
37
    struct ibv_cq *cq = ibv_create_cq(ctx, 16, NULL, NULL, 0);
38

39
    // 6. 创建 QP
40
    struct ibv_qp_init_attr qp_attr = {
41
        .send_cq = cq,
42
        .recv_cq = cq,
43
        .qp_type = IBV_QPT_RC,
44
        .cap = {
45
            .max_send_wr  = 16,
46
            .max_recv_wr  = 16,
47
            .max_send_sge = 1,
48
            .max_recv_sge = 1,
49
        },
50
    };
51
    struct ibv_qp *qp = ibv_create_qp(pd, &qp_attr);
52
    printf("QP 创建成功: qpn=0x%x\n", qp->qp_num);
53

54
    // 7. 修改 QP 状态: RESET → INIT
55
    struct ibv_qp_attr attr;
56
    memset(&attr, 0, sizeof(attr));
57
    attr.qp_state        = IBV_QPS_INIT;
58
    attr.port_num        = 1;
59
    attr.pkey_index      = 0;
60
    attr.qp_access_flags = IBV_ACCESS_REMOTE_WRITE |
61
                           IBV_ACCESS_REMOTE_READ;
62
    ibv_modify_qp(qp, &attr,
63
                   IBV_QP_STATE | IBV_QP_PKEY_INDEX |
64
                   IBV_QP_PORT  | IBV_QP_ACCESS_FLAGS);
65

66
    // 在实际程序中，此处需要与对端交换 QP 信息
67
    // 然后执行 INIT → RTR → RTS 状态转换
68
    // ...
69

70
    printf("RDMA 环境初始化完成\n");
71

72
    // 清理
73
    ibv_destroy_qp(qp);
74
    ibv_destroy_cq(cq);
75
    ibv_dereg_mr(mr);
76
    ibv_dealloc_pd(pd);
77
    ibv_close_device(ctx);
78
    ibv_free_device_list(dev_list);
79
    free(buf);
80

81
    return 0;
82
}

1
# 编译 RDMA 程序
2
gcc -o rdma_write_demo rdma_write_demo.c -libverbs -lrdmacm
3

4
# 运行
5
./rdma_write_demo

1
# 服务端
2
ib_write_bw -d mlx5_0
3

4
# 客户端
5
ib_write_bw -d mlx5_0 <server_ip>
6

7
# 输出示例：
8
# ---------------------------------------------------------------------------------------
9

10
# Dual-port       : OFF          Device         : mlx5_0
11
# Number of qps   : 1            Transport type : IB
12
# Connection type : RC           Using SRQ      : OFF
13
# TX depth        : 128
14
# Mtu             : 1024[B]
15
# Link type       : IB
16
# Max msg size    : 65536[B]
17
# ---------------------------------------------------------------------------------------
18

19
#  65536      5000           24123.             24118.               0.386
20

21
# 测试不同消息大小
22
ib_write_bw -d mlx5_0 -s 1 <server_ip>       # 1 字节
23
ib_write_bw -d mlx5_0 -s 4096 <server_ip>    # 4KB
24
ib_write_bw -d mlx5_0 -s 65536 <server_ip>   # 64KB
25

26
# 测试延迟
27
ib_write_lat -d mlx5_0 <server_ip>
28

29
# 测试 RDMA Read 带宽
30
ib_read_bw -d mlx5_0 <server_ip>
31

32
# 测试 Send/Recv 带宽
33
ib_send_bw -d mlx5_0 <server_ip>
34

35
# 使用双向测试
36
ib_write_bw -d mlx5_0 -b <server_ip>
37

38
# 使用多 QP 测试
39
ib_write_bw -d mlx5_0 -n 4 <server_ip>       # 4 个 QP
40

41
# 使用 Huge Pages
42
ib_write_bw -d mlx5_0 --use_hugepages <server_ip>