【RDMA】RDMA 编程实例（rdma_cm API）

已于 2022-12-30 23:06:35 修改
阅读量7.5k 收藏 35
点赞数 4
分类专栏： RDMA 文章标签： rdma
于 2021-04-23 16:53:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bandaoyu/article/details/116062334
版权

目录

RDMA编程基础

说明

1. RDMA的学习环境搭建

2. RDMA与socket的类比

3. RDMA服务器的代码流程

main（）

{

}

实例

用法

Makefile

服务端server.c

客户端client.c

更多讲解教程

WRITE|READ编程（RDMA read and write with IB verbs）

LINUX 编程例子

作者：bandaoyu  链接：https://blog.csdn.net/bandaoyu/article/details/116062334

RDMA编程基础

存储大师班 | RDMA简介与编程基础 -https://zhuanlan.zhihu.com/p/387549948

bandaoyuRDMA编程入门

说明

1. RDMA的学习环境搭建

RDMA需要专门的RDMA网卡或者InfiniBand卡才能使用，学习RDMA而又没有这些硬件设备，可以使用一个软件RDMA模拟环境，softiwarp ，
- 这是加载地址：https://github.com/zrlio/softiwarp
- 这是安装教程：http://www.reflectionsofthevoid.com/2011/03/how-to-install-soft-iwarp-on-ubuntu.html

更多的rdmacm实例：，
- https://github.com/tarickb/the-geek-in-the-corner
需要注意的是，这个例子里面缺省用的是IPv6连接，如果希望在IPv4环境下测试，需要先改代码用IPv4地址。


2. RDMA与socket的类比

和Socket连接类似，RDMA连接也分为可靠连接和不可靠连接。然而也不完全相同，Socket的可靠连接就是TCP连接，是流式的；不可靠连接也就是UDP，是消息式的。对于RDMA来说，无论是可靠连接和不可靠连接，都是消息式的。
编程角度看，RDMA代码也分为Server端，Client端，也有bind, listen, connect, accept,等动作，然而细节上仍有不少区别。

大家可以关注一下mellonx的vma，貌似可以直接用socket api通信，方便很多：【RDMA】降低CPU除了RDMA (vbers）还是VMA ？|使用socket进行RDMA编程？_bandaoyu的note-CSDN博客前言看介绍，像是mellonx针对其kernel bypass网卡（RDMA网卡）提供的一个lib库，该lib库对外提供socket api，使得用户的程序不需要修改就可以直接使用kernel bypass网卡（如RDMA网卡）。我们都知道RDMA 网卡目前使用的是rdma_cm和vbers api编程，和socket不一样，如果能用socket对RDMA编程，那确实是很大的利好。官网介绍什么是VMA？Mellanox Interconnect Community官方介绍：Mhttps://blog.csdn.net/bandaoyu/article/details/120726746

rdma_cm API说明：

https://linux.die.net/man/3/rdma_create_id （推荐）

https://www.ibm.com/docs/en/aix/7.2?topic=operations-rdma-listen （内容少）

rdma_cm API 管理连接（建立连接和销毁）+vbers api 管理收发

        RDMA主机使用queue pairs（QP）进行通信；主机创建由发送队列SQ和接收队列RQ组成的QP，并使用verbs API将操作post 到这些队列。（所以rdma_cm是管理连接的，收发还是verbs API？）

3. RDMA服务器的代码流程

main（）

{

  1. channel=rdma_create_event_channel
    这一步是创建一个event channel，event channel是RDMA设备在操作完成后，或者有连接请求等事件发生时，用来通知应用程序的通道。其内部就是一个file descriptor, 因此可以进行poll等操作。

  2. rdma_create_id(channel, **id，……)
    这一步创建一个rdma_cm_id, 概念上等价与socket编程时的listen socket。

  3. rdma_bind_addr(id,addr)
    和socket编程一样，也要先绑定一个本地的地址和端口，以进行listen操作。

  4. rdma_listen(id,block)
    开始侦听客户端的连接请求

  5. rdma_get_cm_event（channel，&event）
    这个调用就是作用在第一步创建的event channel上面，要从event channel中获取一个事件。这是个阻塞调用，只有有事件时才会返回。在一切正常的情况下，函数返回时会得到一个 RDMA_CM_EVENT_CONNECT_REQUEST事件，也就是说，有客户端发起连接了。
    在事件的参数里面，会有一个新的rdma_cm_id传入。这点和socket是不同的，socket只有在accept后才有新的socket fd创建。

on_event()

{

     on_connect_request()//RDMA_CM_EVENT_CONNECT_REQUEST

    {

        build_context()

      {

6.ibv_alloc_pd

创建一个protection domain。protection domain可以看作是一个内存保护单位，在内存区域和队列直接建立一个关联关系，防止未授权的访问。

7.ibv_create_comp_channel

和之前创建的event channel类似，这也是一个event channel，但只用来报告【完成队列】里面的事件。当【完成队列】里有新的任务完成时，就通过这个channel向应用程序报告。

8.ibv_create_cq

创建【完成队列】，创建时就指定使用第6步的channel。

}//--end build_context()

9.rdma_create_qp
创建一个queue pair, 一个queue pair包括一个发送queue和一个接收queue. 指定使用前面创建的cq作为完成队列。该qp创建时就指定关联到第6步创建的pd上。

10.ibv_reg_mr
注册内存区域。RDMA使用的内存，必须事先进行注册。这个是可以理解的，DMA的内存在边界对齐，能否被swap等方面，都有要求。

11.rdma_accept
至此，做好了全部的准备工作，可以调用accept接受客户端的这个请求了。 –：）长出一口气 ~~ 且慢，

}

//--end on_connect_request()

12.rdma_ack_cm_event
对于每个从event channel得到的事件，都要调用ack函数，否则会产生内存泄漏。这一步的ack是对应第5步的get。每一次get调用，都要有对应的ack调用。

13.rdma_get_cm_event
继续调用rdma_get_cm_event, 一切正常的话我们此时应该得到 RDMA_CM_EVENT_ESTABLISHED 事件，表示连接已经建立起来。不需要做额外的处理，直接rdma_ack_cm_event就行了

}//--end on_event()

终于可以开始进行数据传输了 ==== (如何传输下篇再说)

参考：http://10.165.104.246:8080/#/c/43882/

4. 关闭连接

  1. 断开连接
    当rdma_get_cm_event返回RDMA_CM_EVENT_DISCONNECTED事件时，表示客户端断开了连接，server端要进行对应的清理。此时可以调用rdma_ack_cm_event释放事件资源。然后依次调用下面的函数，释放连接资源，内存资源，队列资源。

  2. rdma_disconnect

  3. rdma_destroy_qp

  4. ibv_dereg_mr

  5. rdma_destroy_id
    释放同客户端连接的rdma_cm_id

  6. rdma_destroy_id
    释放用于侦听的rdma_cm_id

  7. rdma_destroy_event_channel
    释放 event channel

}

// end main

实例

源码地址- https://github.com/tarickb/the-geek-in-the-corner

用法

[root@localhost 01_basic-client-server]# ./server 
listening on port 42956.

client <server-address> <server-port>
 

Makefile

.PHONY: clean

CFLAGS  := -Wall -g
LDLIBS  := ${LDLIBS} -lrdmacm -libverbs -lpthread

APPS    := server client

all: ${APPS}


clean:
    rm -f ${APPS}

注意：makefile 没有-L 指定lib的路径，所以 -lrdmacm -libverbs -lpthread 对应的库 librdmacm.so libibverbs.so libpthread.so 应放在默认的路径下/usr/lib 或/usr/lib64

server、clicent源码下载：RDMA编程实例源码（rdma_cmAPI）_rdma源码,rdma实例-网络基础文档类资源-CSDN下载

服务端server.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <rdma/rdma_cma.h>

#define TEST_NZ(x) do { if ( (x)) die("error: " #x " failed (returned non-zero)." ); } while (0)
#define TEST_Z(x)  do { if (!(x)) die("error: " #x " failed (returned zero/null)."); } while (0)

const int BUFFER_SIZE = 1024;

struct context {
  struct ibv_context *ctx;
  struct ibv_pd *pd;
  struct ibv_cq *cq;
  struct ibv_comp_channel *comp_channel;

  pthread_t cq_poller_thread;
};

struct connection {
  struct ibv_qp *qp;

  struct ibv_mr *recv_mr;
  struct ibv_mr *send_mr;

  char *recv_region;
  char *send_region;
};

static void die(const char *reason);

static void build_context(struct ibv_context *verbs);
static void build_qp_attr(struct ibv_qp_init_attr *qp_attr);
static void * poll_cq(void *);
static void post_receives(struct connection *conn);
static void register_memory(struct connection *conn);

static void on_completion(struct ibv_wc *wc);
static int on_connect_request(struct rdma_cm_id *id);
static int on_connection(void *context);
static int on_disconnect(struct rdma_cm_id *id);
static int on_event(struct rdma_cm_event *event);

static struct context *s_ctx = NULL;

int main(int argc, char **argv)
{
#if _USE_IPV6
  struct sockaddr_in6 addr;
#else
  struct sockaddr_in addr;
#endif
  struct rdma_cm_event *event = NULL;
  struct rdma_cm_id *listener = NULL;
  struct rdma_event_channel *ec = NULL;
  uint16_t port = 0;

  memset(&addr, 0, sizeof(addr));
#if _USE_IPV6
  addr.sin6_family = AF_INET6;
#else
  addr.sin_family = AF_INET;
#endif

  TEST_Z(ec = rdma_create_event_channel());
  TEST_NZ(rdma_create_id(ec, &listener, NULL, RDMA_PS_TCP));
  TEST_NZ(rdma_bind_addr(listener, (struct sockaddr *)&addr));
  TEST_NZ(rdma_listen(listener, 10)); /* backlog=10 is arbitrary */

  port = ntohs(rdma_get_src_port(listener)); //rdma_get_src_port 返回listener对应的tcp 端口

  printf("listening on port %d.\n", port);

  while (rdma_get_cm_event(ec, &event) == 0) {
    struct rdma_cm_event event_copy;

    memcpy(&event_copy, event, sizeof(*event));
    rdma_ack_cm_event(event);

    if (on_event(&event_copy))
      break;
  }

  rdma_destroy_id(listener);
  rdma_destroy_event_channel(ec);

  return 0;
}

void die(const char *reason)
{
  fprintf(stderr, "%s\n", reason);
  exit(EXIT_FAILURE);
}

void build_context(struct ibv_context *verbs)
{
  if (s_ctx) {
    if (s_ctx->ctx != verbs)
      die("cannot handle events in more than one context.");

    return;
  }

  s_ctx = (struct context *)malloc(sizeof(struct context));

  s_ctx->ctx = verbs;

  TEST_Z(s_ctx->pd = ibv_alloc_pd(s_ctx->ctx));
  TEST_Z(s_ctx->comp_channel = ibv_create_comp_channel(s_ctx->ctx));
  TEST_Z(s_ctx->cq = ibv_create_cq(s_ctx->ctx, 10, NULL, s_ctx->comp_channel, 0)); /* cqe=10 is arbitrary */
  TEST_NZ(ibv_req_notify_cq(s_ctx->cq, 0)); #完成完成队列与完成通道的关联

  TEST_NZ(pthread_create(&s_ctx->cq_poller_thread, NULL, poll_cq, NULL));
}

void build_qp_attr(struct ibv_qp_init_attr *qp_attr)
{
  memset(qp_attr, 0, sizeof(*qp_attr));

  qp_attr->send_cq = s_ctx->cq;
  qp_attr->recv_cq = s_ctx->cq;
  qp_attr->qp_type = IBV_QPT_RC;

  qp_attr->cap.max_send_wr = 10;
  qp_attr->cap.max_recv_wr = 10;
  qp_attr->cap.max_send_sge = 1;
  qp_attr->cap.max_recv_sge = 1;
}

void * poll_cq(void *ctx)
{
  struct ibv_cq *cq;
  struct ibv_wc wc;

  while (1) {
    TEST_NZ(ibv_get_cq_event(s_ctx->comp_channel, &cq, &ctx));
    ibv_ack_cq_events(cq, 1);
    TEST_NZ(ibv_req_notify_cq(cq, 0));

    while (ibv_poll_cq(cq, 1, &wc))
      on_completion(&wc);
  }

  return NULL;
}

void post_receives(struct connection *conn)
{
  struct ibv_recv_wr wr, *bad_wr = NULL;
  struct ibv_sge sge;

  wr.wr_id = (uintptr_t)conn;
  wr.next = NULL;
  wr.sg_list = &sge;
  wr.num_sge = 1;

  sge.addr = (uintptr_t)conn->recv_region;
  sge.length = BUFFER_SIZE;
  sge.lkey = conn->recv_mr->lkey;

  TEST_NZ(ibv_post_recv(conn->qp, &wr, &bad_wr));
}

void register_memory(struct connection *conn)
{
  conn->send_region = malloc(BUFFER_SIZE);
  conn->recv_region = malloc(BUFFER_SIZE);

  TEST_Z(conn->send_mr = ibv_reg_mr(
    s_ctx->pd,
    conn->send_region,
    BUFFER_SIZE,
    0));

  TEST_Z(conn->recv_mr = ibv_reg_mr(
    s_ctx->pd,
    conn->recv_region,
    BUFFER_SIZE,
    IBV_ACCESS_LOCAL_WRITE));
}

void on_completion(struct ibv_wc *wc)
{
  if (wc->status != IBV_WC_SUCCESS)
    die("on_completion: status is not IBV_WC_SUCCESS.");

  if (wc->opcode & IBV_WC_RECV) {
    struct connection *conn = (struct connection *)(uintptr_t)wc->wr_id;

    printf("received message: %s\n", conn->recv_region);

  } else if (wc->opcode == IBV_WC_SEND) {
    printf("send completed successfully.\n");
  }
}

int on_connect_request(struct rdma_cm_id *id)
{
  struct ibv_qp_init_attr qp_attr;
  struct rdma_conn_param cm_params;
  struct connection *conn;

  printf("received connection request.\n");

  build_context(id->verbs);
  build_qp_attr(&qp_attr);

  TEST_NZ(rdma_create_qp(id, s_ctx->pd, &qp_attr));

  id->context = conn = (struct connection *)malloc(sizeof(struct connection));
  conn->qp = id->qp;

  register_memory(conn);
  post_receives(conn);

  memset(&cm_params, 0, sizeof(cm_params));
  TEST_NZ(rdma_accept(id, &cm_params));

  return 0;
}

int on_connection(void *context)
{
  struct connection *conn = (struct connection *)context;
  struct ibv_send_wr wr, *bad_wr = NULL;
  struct ibv_sge sge;

  snprintf(conn->send_region, BUFFER_SIZE, "message from passive/server side with pid %d", getpid());

  printf("connected. posting send...\n");

  memset(&wr, 0, sizeof(wr));

  wr.opcode = IBV_WR_SEND;
  wr.sg_list = &sge;
  wr.num_sge = 1;
  wr.send_flags = IBV_SEND_SIGNALED;

  sge.addr = (uintptr_t)conn->send_region;
  sge.length = BUFFER_SIZE;
  sge.lkey = conn->send_mr->lkey;

  TEST_NZ(ibv_post_send(conn->qp, &wr, &bad_wr));

  return 0;
}

int on_disconnect(struct rdma_cm_id *id)
{
  struct connection *conn = (struct connection *)id->context;

  printf("peer disconnected.\n");

  rdma_destroy_qp(id);

  ibv_dereg_mr(conn->send_mr);
  ibv_dereg_mr(conn->recv_mr);

  free(conn->send_region);
  free(conn->recv_region);

  free(conn);

  rdma_destroy_id(id);

  return 0;
}

int on_event(struct rdma_cm_event *event)
{
  int r = 0;

  if (event->event == RDMA_CM_EVENT_CONNECT_REQUEST)
    r = on_connect_request(event->id);
  else if (event->event == RDMA_CM_EVENT_ESTABLISHED)
    r = on_connection(event->id->context);
  else if (event->event == RDMA_CM_EVENT_DISCONNECTED)
    r = on_disconnect(event->id);
  else
    die("on_event: unknown event.");

  return r;
}

客户端client.c

#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <rdma/rdma_cma.h>

#define TEST_NZ(x) do { if ( (x)) die("error: " #x " failed (returned non-zero)." ); } while (0)
#define TEST_Z(x)  do { if (!(x)) die("error: " #x " failed (returned zero/null)."); } while (0)

const int BUFFER_SIZE = 1024;
const int TIMEOUT_IN_MS = 500; /* ms */

struct context {
  struct ibv_context *ctx;
  struct ibv_pd *pd;
  struct ibv_cq *cq;
  struct ibv_comp_channel *comp_channel;

  pthread_t cq_poller_thread;
};

struct connection {
  struct rdma_cm_id *id;
  struct ibv_qp *qp;

  struct ibv_mr *recv_mr;
  struct ibv_mr *send_mr;

  char *recv_region;
  char *send_region;

  int num_completions;
};

static void die(const char *reason);

static void build_context(struct ibv_context *verbs);
static void build_qp_attr(struct ibv_qp_init_attr *qp_attr);
static void * poll_cq(void *);
static void post_receives(struct connection *conn);
static void register_memory(struct connection *conn);

static int on_addr_resolved(struct rdma_cm_id *id);
static void on_completion(struct ibv_wc *wc);
static int on_connection(void *context);
static int on_disconnect(struct rdma_cm_id *id);
static int on_event(struct rdma_cm_event *event);
static int on_route_resolved(struct rdma_cm_id *id);

static struct context *s_ctx = NULL;

int main(int argc, char **argv)
{
  struct addrinfo *addr;
  struct rdma_cm_event *event = NULL;
  struct rdma_cm_id *conn= NULL;
  struct rdma_event_channel *ec = NULL;

  if (argc != 3)
    die("usage: client <server-address> <server-port>");

  TEST_NZ(getaddrinfo(argv[1], argv[2], NULL, &addr));

  TEST_Z(ec = rdma_create_event_channel());
  TEST_NZ(rdma_create_id(ec, &conn, NULL, RDMA_PS_TCP));
  TEST_NZ(rdma_resolve_addr(conn, NULL, addr->ai_addr, TIMEOUT_IN_MS));

  freeaddrinfo(addr);

  while (rdma_get_cm_event(ec, &event) == 0) {
    struct rdma_cm_event event_copy;

    memcpy(&event_copy, event, sizeof(*event));
    rdma_ack_cm_event(event);

    if (on_event(&event_copy))
      break;
  }

  rdma_destroy_event_channel(ec);

  return 0;
}

void die(const char *reason)
{
  fprintf(stderr, "%s\n", reason);
  exit(EXIT_FAILURE);
}

void build_context(struct ibv_context *verbs)
{
  if (s_ctx) {
    if (s_ctx->ctx != verbs)
      die("cannot handle events in more than one context.");

    return;
  }

  s_ctx = (struct context *)malloc(sizeof(struct context));

  s_ctx->ctx = verbs;

  TEST_Z(s_ctx->pd = ibv_alloc_pd(s_ctx->ctx));
  TEST_Z(s_ctx->comp_channel = ibv_create_comp_channel(s_ctx->ctx));
  TEST_Z(s_ctx->cq = ibv_create_cq(s_ctx->ctx, 10, NULL, s_ctx->comp_channel, 0)); /* cqe=10 is arbitrary */
  TEST_NZ(ibv_req_notify_cq(s_ctx->cq, 0));

  TEST_NZ(pthread_create(&s_ctx->cq_poller_thread, NULL, poll_cq, NULL));
}

void build_qp_attr(struct ibv_qp_init_attr *qp_attr)
{
  memset(qp_attr, 0, sizeof(*qp_attr));

  qp_attr->send_cq = s_ctx->cq;
  qp_attr->recv_cq = s_ctx->cq;
  qp_attr->qp_type = IBV_QPT_RC;

  qp_attr->cap.max_send_wr = 10;
  qp_attr->cap.max_recv_wr = 10;
  qp_attr->cap.max_send_sge = 1;
  qp_attr->cap.max_recv_sge = 1;
}

void * poll_cq(void *ctx)
{
  struct ibv_cq *cq;
  struct ibv_wc wc;

  while (1) {
    TEST_NZ(ibv_get_cq_event(s_ctx->comp_channel, &cq, &ctx));
    ibv_ack_cq_events(cq, 1);
    TEST_NZ(ibv_req_notify_cq(cq, 0));

    while (ibv_poll_cq(cq, 1, &wc))
      on_completion(&wc);
  }

  return NULL;
}

void post_receives(struct connection *conn)
{
  struct ibv_recv_wr wr, *bad_wr = NULL;
  struct ibv_sge sge;

  wr.wr_id = (uintptr_t)conn;
  wr.next = NULL;
  wr.sg_list = &sge;
  wr.num_sge = 1;

  sge.addr = (uintptr_t)conn->recv_region;
  sge.length = BUFFER_SIZE;
  sge.lkey = conn->recv_mr->lkey;

  TEST_NZ(ibv_post_recv(conn->qp, &wr, &bad_wr));
}

void register_memory(struct connection *conn)
{
  conn->send_region = malloc(BUFFER_SIZE);
  conn->recv_region = malloc(BUFFER_SIZE);

  TEST_Z(conn->send_mr = ibv_reg_mr(
    s_ctx->pd, 
    conn->send_region, 
    BUFFER_SIZE, 
    0));

  TEST_Z(conn->recv_mr = ibv_reg_mr(
    s_ctx->pd, 
    conn->recv_region, 
    BUFFER_SIZE, 
    IBV_ACCESS_LOCAL_WRITE));
}

int on_addr_resolved(struct rdma_cm_id *id)
{
  struct ibv_qp_init_attr qp_attr;
  struct connection *conn;

  printf("address resolved.\n");

  build_context(id->verbs);
  build_qp_attr(&qp_attr);

  TEST_NZ(rdma_create_qp(id, s_ctx->pd, &qp_attr));

  id->context = conn = (struct connection *)malloc(sizeof(struct connection));

  conn->id = id;
  conn->qp = id->qp;
  conn->num_completions = 0;

  register_memory(conn);
  post_receives(conn);

  TEST_NZ(rdma_resolve_route(id, TIMEOUT_IN_MS));

  return 0;
}

void on_completion(struct ibv_wc *wc)
{
  struct connection *conn = (struct connection *)(uintptr_t)wc->wr_id;

  if (wc->status != IBV_WC_SUCCESS)
    die("on_completion: status is not IBV_WC_SUCCESS.");

  if (wc->opcode & IBV_WC_RECV)
    printf("received message: %s\n", conn->recv_region);
  else if (wc->opcode == IBV_WC_SEND)
    printf("send completed successfully.\n");
  else
    die("on_completion: completion isn't a send or a receive.");

  if (++conn->num_completions == 2)
    rdma_disconnect(conn->id);
}

int on_connection(void *context)
{
  struct connection *conn = (struct connection *)context;
  struct ibv_send_wr wr, *bad_wr = NULL;
  struct ibv_sge sge;

  snprintf(conn->send_region, BUFFER_SIZE, "message from active/client side with pid %d", getpid());

  printf("connected. posting send...\n");

  memset(&wr, 0, sizeof(wr));

  wr.wr_id = (uintptr_t)conn;
  wr.opcode = IBV_WR_SEND;
  wr.sg_list = &sge;
  wr.num_sge = 1;
  wr.send_flags = IBV_SEND_SIGNALED;

  sge.addr = (uintptr_t)conn->send_region;
  sge.length = BUFFER_SIZE;
  sge.lkey = conn->send_mr->lkey;

  TEST_NZ(ibv_post_send(conn->qp, &wr, &bad_wr));

  return 0;
}

int on_disconnect(struct rdma_cm_id *id)
{
  struct connection *conn = (struct connection *)id->context;

  printf("disconnected.\n");

  rdma_destroy_qp(id);

  ibv_dereg_mr(conn->send_mr);
  ibv_dereg_mr(conn->recv_mr);

  free(conn->send_region);
  free(conn->recv_region);

  free(conn);

  rdma_destroy_id(id);

  return 1; /* exit event loop */
}

int on_event(struct rdma_cm_event *event)
{
  int r = 0;

  if (event->event == RDMA_CM_EVENT_ADDR_RESOLVED)
    r = on_addr_resolved(event->id);
  else if (event->event == RDMA_CM_EVENT_ROUTE_RESOLVED)
    r = on_route_resolved(event->id);
  else if (event->event == RDMA_CM_EVENT_ESTABLISHED)
    r = on_connection(event->id->context);
  else if (event->event == RDMA_CM_EVENT_DISCONNECTED)
    r = on_disconnect(event->id);
  else
    die("on_event: unknown event.");

  return r;
}

int on_route_resolved(struct rdma_cm_id *id)
{
  struct rdma_conn_param cm_params;

  printf("route resolved.\n");

  memset(&cm_params, 0, sizeof(cm_params));
  TEST_NZ(rdma_connect(id, &cm_params));

  return 0;
}

更多讲解教程

InfiniBand, Verbs, RDMA | https://thegeekinthecorner.wordpress.com/category/infiniband-verbs-rdma/

RDMA read and write with IB verbs | https://thegeekinthecorner.wordpress.com/2010/09/28/rdma-read-and-write-with-ib-verbs/

http://www.hpcadvisorycouncil.com/pdf/building-an-rdma-capable-application-with-ib-verbs.pdf

WRITE|READ编程（RDMA read and write with IB verbs）

（本文讲解的示例代码在：RDMA read and write with IB verbs | The Geek in the Corner）


在《4. RDMA操作类型|WRITE|READ》后半段：https://blog.csdn.net/bandaoyu/article/details/112861454

LINUX 编程例子

https://community.mellanox.com/s/topic/0TO50000000g1zhGAA/linux-programming?tabset-dea0d=2

4、rdma_listen()和rdma_request()是否要在一起执行？

不一定。rdma_listen()不是阻塞式方法，只是监听连接请求，不会产生新的连接rdma_cm_id，如果想产生新的rdma_cm_id，需要执行rdma_get_cm_event()获取RDMA_CM_EVENT_CONNECT_REQUEST事件，或者执行rdma_get_request()获取连接请求事件。所以rdma_get_cm_event()和rdma_get_request()的原理是相同的，都是为了获取RDMA_CM_EVENT_CONNECT_REQUEST事件，表示有客户端连接，然后会产生新的rdma_cm_id，也就是连接rdma_cm_id。对于传统的TCP/IP通信，listen阶段只是监听，accept之后才产生新的socket fd，但是RDMA中，在listen阶段即可产生新的rdma_cm_id，更为准确来说，是在listen调用之后，只要有RDMA_CM_EVENT_CONNECT_REQUEST事件产生，就会生成新的rdma_cm_id。尝试过，如果只有listen，没有request，就会报错。可见，listen之后需要有相应的处理机制才可以。

5、为什么要设置IBV_SEND_INLINE？

原因：https://blog.csdn.net/bandaoyu/article/details/119207147

int send_flags，描述了WR的属性，其值为0或者一个或多个flags的按位异或。

IBV_SEND_FENCE - 为此WR设置围栏指示器。这意味着这个WR的处理将被阻止，直到所有之前发布的RDMA Read和Atomic WR都将被完成。仅对运输服务类型为IBV_QPT_RC的QP有效

IBV_SEND_SIGNALED - 设置此WR的完成通知指示符。这意味着如果QP是使用sq_sig_all = 0创建的，那么当WR的处理结束时，将会产生一个工作完成。如果QP是使用sq_sig_all = 1创建的，则不会对此标志产生任何影响

IBV_SEND_SOLICITED - 为此WR设置请求事件指示器。这意味着，当这个WR中的消息将在远程QP中结束时，将会创建一个请求事件，如果在远程侧，用户正在等待请求事件，它将被唤醒。与仅用于发送和RDMA写入的立即操作码相关

IBV_SEND_INLINE - sg_list中指定的内存缓冲区将内联放置在发送请求中。这意味着低级驱动程序（即CPU）将读取数据而不是RDMA设备。这意味着L_Key将不会被检查，实际上这些内存缓冲区甚至不需要被注册，并且在ibv_post_send（）结束之后可以立即重用。仅对发送和RDMA写操作码有效。由于在该代码中没有涉及到key的交换，所以也无法使用RDMA传输，所以还是使用了CPU读取数据，既然是CPU读取，那么也就不需要注册内存缓冲区了，这个标记只能用于发送和写操作。

6、操作码和对应的QP传输服务类型的关系？

@UESTC

CQE's wr_id could be:
1)BEACON_WRID
2)&RDMAConnectedSocketImpl::qp
3)Chunks address start from Cluster::chunk_base
When assuming qp as Chunk through CQE's wr_id, it's possible to misjudge
&(qp->ib_physical_port) into Cluster::[base, end) because there're 4 bytes
random data filled in the higher 4 bytes address around ib_pysical_port due
to the address alignement requirement of structure member.

Fix this case by checking whether wr_id value is in the allocated Chunk space.
Fixes: https://tracker.ceph.com/issues/44346

msg/async/rdma: use wr_id address to check valid chunk by rosinL ·https://github.com/ceph/ceph/pull/36908

RDMA 编程手册

《RDMA_Aware_Programming_user_manual》

https://download.csdn.net/download/bandaoyu/87354001?spm=1001.2014.3001.5501 

bandaoyu
关注
  • 4
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【RDMA】RDMA SEND/WRITE编程实例（IBV Verbs ）
小鱼菜鸟的博客
07-22 820
目录 前言 RDMA编程基础 更多例子 基于Verbs的RDMA RC通信编程示例概要 Main() { print_config() resources_init() resources_create() sock_connect() connect_qp() post_send poll_completion resour...
RDMA编程用户手册-官方中文版.pdf
10-19
工作需要,将这个 Mellanox 的编程用户手册(RDMA_Aware_Programming_user_manual.pdf)翻译成了中文，便于大家 学习参考。其中第一章和第二章参考了网络上的一些已有翻译，并做了部分纠 错。其他借助了 google 翻译。发布时候我会同时上传英文原版和翻译版，以便 纠错。
RDMA编程用户手册
04-10
RDMA aware programming user manual libibverbs user manual / document
RDMA中文编程手册，1.7版本
06-10
RDMA中文编程手册，1.7版本
rdma 编程详解
02-14 2635
1.相关名词解释 1.1 rdma-core 指开源RDMA用户态软件协议栈，（用户空间的驱动）包含用户态框架、各厂商用户态驱动、API帮助手册以及开发自测试工具等。 rdma-core在github上维护，我们的用户态Verbs API实际上就是它实现的。https://github.com/linux-rdma/rdma-core 1.2 kernel RDMA subsystem 指开源的Linux内核中的RDMA子系统，（内核空间的驱动）包含RDMA内核框架及各厂商的驱动。 RDMA子系统.
c语言利用RDMA技术实现客户端和服务器端互相读取对方内存
04-10
c语言利用RDMA技术实现客户端和服务器端互相读取对方内存。包含server.c和client.c ，gcc编译方法和使用方法
rdma_cm.rar_event
09-23
Upon receiving a device removal event, users must destroy the associated RDMA identifier and release all resources allocated with the device.
RDMA编程1 建立侦听
热门推荐
winux的专栏
06-28 1万+
RDMA编程 server端开发 Server端如何进行侦听和建立连接
【RDMA】RDMA编程入门--编辑中
小鱼菜鸟的博客
07-22 1396
目录 一、前言 二、基本概念 1、队列和队列成员 2、传输模式 简介 单边双边传输流程简述 3、编程接口(verbs API) 三、编程示例 工作大致流程说明 编程代码实例 四、RDMA通信和ceph AsyncMessenger的关系 【RDMA】RDMA 学习资料总目录_bandaoyu的博客-CSDN博客SavirRDMA ...
【RDMA】RDMA技术详解（四）：RDMA之Verbs和编程步骤
小鱼菜鸟的博客
01-20 2348
目录 什么是Verbs 相关名词解释 Verbs API Verbs API是什么 设计Verbs API的原因 Verbs API所包含的内容 使用Verbs API编写RDMA应用程序 查看接口定义 包含头文件 编写应用 编译 & 执行 官方示例程序 libibverbs librdmacm 参考文献 ibv_...
【RDMA】rdma_cm和verbs的区别|libibverbs和librdmacm的区别--还在研究中
bandaoyu的note
04-13 5409
ib_verbs和rdma_cm 都是Mellanox公司提供的两个动态链接库。(这两个库的API ，queue pair (QP) 类似于 TCP的sockets) rdma_cm，连接管理器库，包含了对ib_verbs的封装或具体化，通过verbs API 对硬件进行访问。 libibverbs和librdmacm的区别？ 在infiniband/verbs.h中，定义了ibv_post_send()和ibv_post_recv()操作，分别表示，将wr发布到SQ和RQ中，至于是什么...
ib_rdma.rar_rdma
09-24
This is stored as mr->r_trans_private.
rdma.rar_364S_libverbs_libverbs 是什么_rdma 开发_rdma_put_verbs
09-14
rdma编程实例 libverbs librdma库
RDMA编程实例源码（rdma_cm API）
05-12
RDMA编程实例源码（rdma_cm API）
RDMA_Aware_Programming_user_manual.zip
12-18
这个是mellanox公司的RDMA官方文档。可以和博客对照着看。英文的有些词确实难以翻译。觉得奇怪的地方可以看一下原文。
RDMA编程手册11111
09-21
RDMA_Aware_Programming_user_manual1.7.pdf,最新手册，之前在csdn下载了一个，太旧了，上传一个最新的供大家实用。手册介绍ofed相关接口用法，最详细，没有之一。
RDMA_RC_example.c
09-27
RDMA SEND/WRITE编程实例（IBV Verbs ）
RDMA_Aware_Programming_user_manual.rar
06-03
Chapter 4 RDMA_CM API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 Chapter 5 RDMA Verbs API . . . . . . . . . . . . . . . . . . . . . . . . . . . . ...
RDMA编程养成记
最新发布
happy_fish100的博客
12-16 949
FastCFS如何以原生方式适配RDMA以及踩过的那些坑，希望对大家有所帮助。
RDMA编程环境搭建
10-13
要搭建RDMA编程环境，需要以下步骤： 1. 确认硬件支持RDMA，包括网卡、主板和CPU等。 2. 安装操作系统，推荐使用Linux发行版，如CentOS、Ubuntu等。 3. 安装RDMA驱动程序，如OFED（OpenFabrics Enterprise Distribution）。 4. 安装RDMA编程库，如libibverbs、librdmacm等。 5. 配置RDMA环境变量，如LD_LIBRARY_PATH等。 具体的步骤可以参考相关的文档和教程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值