RDMA高性能网络通信实践

已于 2025-05-02 05:50:07 修改
阅读量527 收藏 10
点赞数 4
分类专栏： 学习 文章标签： RDMA 网络 学习 通信 分布式
于 2025-05-01 12:00:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61864577/article/details/147646163
版权

RDMA高性能网络通信实践

一、背景介绍

远程直接内存访问（RDMA）技术通过绕过操作系统内核和CPU直接访问远程内存，实现了超低延迟、高吞吐量的网络通信。该技术广泛应用于高性能计算、分布式存储和机器学习等领域。本文通过一个完整的代码示例，演示如何利用RDMA核心组件（QP、MR、CQ等）实现跨节点内存直接读写。

二、方法设计

A.实现方案

  1. 控制平面：使用TCP协议交换RDMA连接参数
  2. 数据平面：基于IB Verbs接口实现零拷贝传输
  3. 混合模式：客户端主动写入，服务端被动读取

B.关键技术点

  • 内存注册机制实现安全访问
  • QP状态机转换确保通信可靠性
  • 完成队列轮询实现异步通知
  • 端到端流控通过TCP协议实现

三、代码及注释

/*----------------------------- 头文件包含 -----------------------------*/
// 标准库和网络相关头文件
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>
#include <assert.h>
#include <errno.h>
#include <sys/time.h>
#include <byteswap.h>

// RDMA相关头文件
#include <arpa/inet.h>
#include <infiniband/verbs.h>

#ifdef USE_VACC
#include "vaccrt.h"
#include <vaccrt_mem_management.h>
#endif

#ifdef USE_CUDA
#include <cuda.h>
#include <cuda_runtime.h>
#endif

/**********************************************************************

A.关键概念解释：
  1.保护域（PD）：资源隔离单元，所有资源（QP、MR等）必须属于某个PD
  2.内存区域（MR）：注册的内存区域，只有注册的内存才能用于RDMA操作
  3.队列对（QP）：包含发送队列和接收队列，是通信的基本单元
  4.工作请求（WR）：描述要执行的操作（发送/接收/RDMA读写）
  5.完成队列（CQ）：用于通知操作完成状态
  6.QP状态转换：
    a.INIT：初始状态，设置基本参数
    b.RTR（Ready to Receive）：准备好接收数据
    c.RTS（Ready to Send）：准备好发送数据

B.程序流程总结：
  1.通过TCP交换RDMA连接参数
  2.初始化IB资源（PD、CQ、MR、QP）
  3.交换QP信息（地址、密钥等）
  4.进行QP状态转换（INIT->RTR->RTS）
  5.执行RDMA写/读操作
  6.轮询完成队列确认操作完成
  7.清理资源

C.使用说明:
  1.编译命令: 
    gcc -o cuda -DUSE_CUDA -ggdb main.c -pthread -libverbs \
            -I /usr/local/cuda/include \
            -L /usr/local/cuda/lib64 -Wl,-rpath=/usr/local/cuda/lib64 \
            -lcudart -lcudadevrt -lcuda  
  2.服务端  : 
  ./cuda 192.168.1.100 mlx5_0
  3.客户端  : 
  ./cuda 192.168.1.101 mlx5_0 192.168.1.100 
      
***********************************************************************/

/*----------------------------- 全局配置 -----------------------------*/
#define MAX_POLL_CQ_TIMEOUT 6000    // CQ轮询超时时间（毫秒）
#define MSG "Hello,World"           // 要传输的测试消息
#define MSG_SIZE (64<<10)

// 配置参数结构体
struct config {
    const char *dev;      // IB设备名称
    char *local_addr;     // 本地IP地址
    u_int32_t port;       // TCP端口号
    int ib_port;          // IB端口号（默认1）
    int gid_idx;          // GID索引（-1表示不使用RoCEv2）
} config = { NULL, NULL, 12025, 1, -1 };


/*----------------------------- 资源结构体 -----------------------------*/
// 包含所有RDMA相关资源
struct resources {
    struct ibv_context *ctx;        // IB上下文
    struct ibv_pd *pd;              // 保护域（Protection Domain）
    struct ibv_cq *cq;              // 完成队列（Completion Queue）
    struct ibv_qp *qp;              // 队列对（Queue Pair）
    struct ibv_mr *mr;              // 内存区域（Memory Region）
    void *buf;                      // 数据缓冲区指针
    int sock;                       // TCP套接字
    uint64_t remote_addr;           // 远程内存地址
    uint32_t remote_rkey;           // 远程内存访问密钥
    struct ibv_port_attr port_attr; // IB端口属性
};

/*----------------------------- 辅助函数 -----------------------------*/
/**
 * 建立TCP连接（客户端）或监听（服务端）
 * @param server 本地地址（服务端模式时使用）
 * @param port TCP端口号
 * @param remote_addr 远程地址（客户端模式时使用）
 * @return 成功返回套接字fd，失败返回-1
 */
int sock_connect(const char *server, int port,const char *remote_addr) {
    struct addrinfo hints = { .ai_family = AF_INET, .ai_socktype = SOCK_STREAM };
    struct addrinfo *res, *p;
    int sock = -1;
    char port_str[6];
    const char * p_addr=server;
    if(remote_addr) p_addr=remote_addr;

    sprintf(port_str, "%d", port);
    if (getaddrinfo(p_addr, port_str, &hints, &res)) return -1;

    for (p = res; p; p = p->ai_next) {
        sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
        int reuse = 1;
        if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse))) return -1;        
        if (sock < 0) continue;
        if (remote_addr) {
            if (connect(sock, p->ai_addr, p->ai_addrlen)) { close(sock); sock = -1; }
            else break;
        } else {
            if (bind(sock, p->ai_addr, p->ai_addrlen) || listen(sock, 1)) { close(sock); sock = -1; }
            else { sock = accept(sock, NULL, 0); break; }
        }
    }
    freeaddrinfo(res);
    return sock;
}

/**
 * 通过TCP同步交换数据
 * @return 成功返回0，失败返回-1
 */
int sock_sync(int sock, int size, void *local, void *remote) {
    if (write(sock, local, size) != size) return -1;
    return read(sock, remote, size) == size ? 0 : -1;
}

/**
 * 轮询完成队列直到操作完成或超时
 * @return 成功返回0，失败返回-1
 */
int poll_cq(struct ibv_cq *cq) {
    struct ibv_wc wc;
    unsigned long start = time(NULL) * 1000;
    while (time(NULL) * 1000 - start < MAX_POLL_CQ_TIMEOUT) {
        if (ibv_poll_cq(cq, 1, &wc) && wc.status == IBV_WC_SUCCESS) return 0;
    }
    return -1;
}

/**
 * 提交发送工作请求（Work Request）
 * @param res 资源结构体指针
 * @param op 操作类型（IBV_WR_RDMA_WRITE/READ）
 */
void post_send(struct resources *res, int op) {
    struct ibv_send_wr sr;
    struct ibv_sge sge;
    struct ibv_send_wr *bad_wr = NULL;

    memset(&sge, 0, sizeof(sge));
    sge.addr = (uintptr_t)res->buf;
    sge.length = res->mr->length;
    sge.lkey = res->mr->lkey;

    memset(&sr, 0, sizeof(sr));
    sr.next = NULL;
    sr.wr_id = 0;
    sr.sg_list = &sge;
    sr.num_sge = 1;
    sr.opcode = op;
    sr.send_flags = IBV_SEND_SIGNALED;
    sr.wr.rdma.remote_addr = res->remote_addr;
    sr.wr.rdma.rkey = res->remote_rkey;
    assert(0==ibv_post_send(res->qp, &sr, &bad_wr));
}

/*----------------------------- 主函数 -----------------------------*/
int main(int argc, char **argv) {
    struct resources res = {0};
    char *remote_addr=0;
    
    //分配HOST或设备内存
    #ifdef USE_CPU
    res.buf = malloc(MSG_SIZE);
    memset(res.buf,0,MSG_SIZE);
    #endif    
    
    #ifdef USE_CUDA
    cuInit(0);
    CUdevice cuDevice;
    cuDeviceGet(&cuDevice, 0);
    CUcontext cuContext;
    assert(0 == cuCtxCreate(&cuContext, 0, cuDevice));
    assert(0 == cudaMallocHost(&res.buf, MSG_SIZE));
    struct cudaPointerAttributes cu_attrs;
    assert(0==cudaPointerGetAttributes(&cu_attrs,res.buf));
    unsigned cuflags = 1;
    assert(0==cuPointerSetAttribute(&cuflags, CU_POINTER_ATTRIBUTE_SYNC_MEMOPS,
                                  (CUdeviceptr)cu_attrs.devicePointer));
    assert(res.buf);
    cudaMemset(res.buf,0,MSG_SIZE);
    #endif    

    #ifdef USE_VACC
    int DevId=0;
    assert(0==vaccrtSetDevice(DevId));   
    assert(0==vaccrtMalloc(64<<10,MSG_SIZE,&res.buf));
    assert(0==vaccrtMemset(res.buf,0,MSG_SIZE)); 
    int mem_handle=0;
    assert(0==vaccrtMemGetHandleForAddressRange(&mem_handle,res.buf, MSG_SIZE,VACCRT_MEM_RANGE_HANDLE_TYPE_DMA_BUF_FD,0));
    printf("mem_handle:%d ddr:%p\n",mem_handle,res.buf);
    #endif
    printf("init done\n");
    
    // 参数解析：本地地址必须，设备名必须，远程地址可选
    config.local_addr = argv[1];    // 本地IP地址
    char *dev_name = argv[2];       // IB设备名（如mlx5_0）
    if(argc > 3) remote_addr = argv[3];  // 远程IP地址（客户端模式）
    
    /*=============== 阶段1：建立TCP连接 ===============*/
    // 用于交换RDMA连接参数（QPN、LID、内存地址等）    
    res.sock = sock_connect(config.local_addr, config.port,remote_addr);
    assert(res.sock>=0);
    
    /*=============== 阶段2：初始化IB资源 ===============*/
    // 1. 获取IB设备列表并打开指定设备    
    int num_devices=0;
    struct ibv_device * cur_dev=NULL;
    struct ibv_device **dev_list = ibv_get_device_list(&num_devices);
    for (int i = 0; i < num_devices; i++) {
        const char *name = ibv_get_device_name(dev_list[i]);
        printf("%d:%s\n",i,name);
        if (dev_name && strcmp(name, dev_name) == 0) {
            res.ctx = ibv_open_device(dev_list[i]);  
            cur_dev=dev_list[i];
              break;
        }
    }    
    assert(res.ctx);
    
    // 2. 查询IB端口属性（获取LID等信息）
    assert(0==ibv_query_port(res.ctx,1, &res.port_attr));
    
    // 3. 创建保护域（PD），用于管理资源权限
    res.pd = ibv_alloc_pd(res.ctx);
    assert(res.pd);
    
    // 4. 创建完成队列（CQ），用于接收操作完成通知
    res.cq = ibv_create_cq(res.ctx, 1, NULL, NULL, 0);
    assert(res.cq);
    
    // 5. 注册内存区域（MR），允许远程访问   
    int mr_flags=IBV_ACCESS_LOCAL_WRITE | IBV_ACCESS_REMOTE_WRITE | IBV_ACCESS_REMOTE_READ;
    #ifdef USE_CPU
    res.mr = ibv_reg_mr(res.pd, res.buf, MSG_SIZE,mr_flags );
    #endif
    
    #ifdef USE_VACC
    res.mr = ibv_reg_dmabuf_mr(res.pd,0,MSG_SIZE,(uint64_t)res.buf,mem_handle,mr_flags);
    #endif 
    
    #ifdef USE_CUDA
    res.mr = ibv_reg_mr(res.pd, res.buf, MSG_SIZE,mr_flags);   
    #endif
    if(0==res.mr)
    {
        printf("ibv_reg_mr %s (错误码=%d)\n", strerror(errno), errno);
        return -1;
    }
    
    // 6. 创建队列对（QP），RC（可靠连接）类型
    struct ibv_qp_init_attr qp_init_attr;
    memset(&qp_init_attr, 0, sizeof(qp_init_attr));
    qp_init_attr.qp_type = IBV_QPT_RC;
    qp_init_attr.sq_sig_all = 1;
    qp_init_attr.send_cq = res.cq;
    qp_init_attr.recv_cq = res.cq;
    qp_init_attr.cap.max_send_wr = 1;
    qp_init_attr.cap.max_recv_wr = 1;
    qp_init_attr.cap.max_send_sge = 1;
    qp_init_attr.cap.max_recv_sge = 1;
      
    res.qp = ibv_create_qp(res.pd, &qp_init_attr);
    assert(res.qp);
    
    /*=============== 阶段3：交换QP参数 ===============*/
    // 通过TCP交换双方的QP信息（地址、密钥等）    
    union ibv_gid my_gid;
    assert(0==ibv_query_gid(res.ctx, 1,0,&my_gid));
    
    // 本地参数打包
    struct { 
        uint64_t addr;    // 内存地址
        uint16_t lid;     // 本地标识符
        uint32_t rkey;    // 内存访问密钥
        uint32_t qpn;     // QP编号
        uint8_t gid[16];  // 全局标识符（RoCEv2需要）
    } local = {
        (uintptr_t)res.buf,
        res.port_attr.lid,
        res.mr->rkey,
        res.qp->qp_num
    },remote;
    memcpy(local.gid, &my_gid, 16);
    
    // 参数交换（TCP同步）
    assert(0 == sock_sync(res.sock, sizeof(local), &local, &remote));
    
    // 保存远程参数
    res.remote_addr = remote.addr;
    res.remote_rkey = remote.rkey;
    
    printf("local: addr=%p, lkey=0x%x, rkey=0x%x\n", res.mr->addr, res.mr->lkey, res.mr->rkey);
    printf("remote: addr=%ld, rkey=0x%x\n", remote.addr, remote.rkey);
        
    /*=============== 阶段4：QP状态转换 ===============*/
    // QP需要经历三个状态变化：INIT -> RTR（准备接收） -> RTS（准备发送）
    
    // 1. INIT状态设置
    struct ibv_qp_attr attr;
    memset(&attr, 0, sizeof(attr));
    attr.qp_state = IBV_QPS_INIT;
    attr.port_num = 1;
    attr.pkey_index = 0;
    attr.qp_access_flags = IBV_ACCESS_LOCAL_WRITE | IBV_ACCESS_REMOTE_READ | IBV_ACCESS_REMOTE_WRITE;
    int flags = IBV_QP_STATE | IBV_QP_PKEY_INDEX | IBV_QP_PORT |
                    IBV_QP_ACCESS_FLAGS;
        
    assert(0==ibv_modify_qp(res.qp, &attr, flags));
    
    // 2. RTR状态设置（准备接收）
    memset(&attr, 0, sizeof(attr));
    attr.qp_state = IBV_QPS_RTR;
    attr.path_mtu = IBV_MTU_256;
    attr.dest_qp_num = remote.qpn;
    attr.rq_psn = 0;
    attr.max_dest_rd_atomic = 1;
    attr.min_rnr_timer = 0x12;
    attr.ah_attr.is_global = 1;
    attr.ah_attr.dlid = remote.lid;
    attr.ah_attr.sl = 0;
    attr.ah_attr.src_path_bits = 0;
    attr.ah_attr.port_num = 1;
    attr.ah_attr.is_global = 1;
    attr.ah_attr.port_num = 1;
    // 如果是RoCEv2需要设置GRH
    attr.ah_attr.grh.flow_label = 0;
    attr.ah_attr.grh.hop_limit = 1;
    attr.ah_attr.grh.sgid_index = 0;
    attr.ah_attr.grh.traffic_class = 0;
    memcpy(&attr.ah_attr.grh.dgid, remote.gid, 16);
   
    flags = IBV_QP_STATE | IBV_QP_AV | IBV_QP_PATH_MTU | IBV_QP_DEST_QPN |
                IBV_QP_RQ_PSN | IBV_QP_MAX_DEST_RD_ATOMIC |
                IBV_QP_MIN_RNR_TIMER;
        
    assert(0==ibv_modify_qp(res.qp, &attr,flags));
    
    // 3. RTS状态设置（准备发送）
    memset(&attr, 0, sizeof(attr));
    attr.qp_state = IBV_QPS_RTS;
    attr.timeout = 0x12;
    attr.retry_cnt = 6;
    attr.rnr_retry = 0;
    attr.sq_psn = 0;
    attr.max_rd_atomic = 1;
    flags = IBV_QP_STATE | IBV_QP_TIMEOUT | IBV_QP_RETRY_CNT |
                IBV_QP_RNR_RETRY | IBV_QP_SQ_PSN | IBV_QP_MAX_QP_RD_ATOMIC;
    assert(0==ibv_modify_qp(res.qp, &attr,flags ));


    /*=============== 阶段5：数据传输 ===============*/
    if (remote_addr) {// 客户端模式，执行RDMA Write
        #ifdef USE_CPU
            strcpy(res.buf, MSG);
        #endif

        #ifdef USE_CUDA
            assert(0==cudaMemcpy(res.buf, MSG, strlen(MSG), cudaMemcpyHostToDevice));
        #endif
            
        #ifdef USE_VACC
            assert(0==vaccrtMemcpy(MSG,strlen(MSG),res.buf,kHost2Ddr));  
        #endif
        post_send(&res, IBV_WR_RDMA_WRITE);// 将本地数据写入远程内存
    } else {                               // 服务端模式，执行RDMA Read
        post_send(&res, IBV_WR_RDMA_READ); // 从远程内存读取数据到本地
    }
    
    // 等待操作完成
    assert(0==poll_cq(res.cq));

    #ifdef USE_VACC
    {
        char buffer[MSG_SIZE];
        memset(buffer,0,MSG_SIZE);
        assert(0==vaccrtMemcpy(res.buf,strlen(MSG),buffer,kDdr2Host));  
        printf("Message: %s\n", buffer);
    }
    #endif
    
    #ifdef USE_CUDA
    {
        char buffer[MSG_SIZE];
        memset(buffer,0,MSG_SIZE);
        assert(0==cudaMemcpy(buffer,res.buf,strlen(MSG),cudaMemcpyDeviceToHost));  
        printf("Message: %s\n", buffer);
    }
    #endif
        
    #ifdef USE_CPU
    printf("Message: %s\n", (const char*)res.buf);
    #endif

    printf("end,Enter exit..\n");
    getchar(),getchar();
    
    /*=============== 阶段6：资源清理 ===============*/
    // 注意销毁顺序：QP -> MR -> CQ -> PD -> 上下文
    ibv_destroy_qp(res.qp);
    ibv_dereg_mr(res.mr);
    
    #ifdef USE_CUDA
    cudaFree(res.buf);
    #endif
    
    #ifdef USE_VACC
    vaccrtFree(res.buf);
    #endif
    
    #ifdef USE_CPU
    free(res.buf);
    #endif
    
    ibv_destroy_cq(res.cq);
    ibv_dealloc_pd(res.pd);
    ibv_close_device(res.ctx);
    close(res.sock);
    ibv_free_device_list(dev_list);
    return 0;
}

四、注意事项

  • 1.ibv_reg_dmabuf_mr需要传入之前分配的设备地址,否则会出
    mlx5_0/1: QP 574 error: local protection error (0x3b 0x0 0x9d)
  • 2.MAX_POLL_CQ_TIMEOUT值太小,会超时
  • 3.cudaMalloc的内存在ibv_reg_mr时提示地址非法
  • 4.收发完毕后才能释放资源
RDMA协议原理与零拷贝高吞吐网络通信实践
qq_40552871的博客
04-08 519
RDMA（Remote Direct Memory Access）即远程直接内存访问，是一种允许网络中的计算机直接从另一台计算机的内存中读取或写入数据的技术，而无需经过CPU的介入。RDMA的核心优势在于能够显著降低网络通信的延迟和CPU的负载，从而提高网络通信的效率和性能。在传统的网络通信中，数据传输需要经过多个步骤，包括操作系统内核的上下文切换、数据在用户空间和内核空间之间的拷贝等，这些操作都会消耗大量的CPU资源和时间。
云计算中Azure存储系统利用远程直接内存访问（RDMA）提升性能的技术探索与实践
11-28
最终，在所有Azure公共区域都支持了区域内RDMA，使70%的流量实现了高性能的RDMA通信，并大幅提升了磁盘I/O性能和CPU利用率。 适合人群：对云基础设施、网络技术和存储系统有浓厚兴趣的研究者和技术专家，尤其适用于...
RDMA高性能网络的优势和实践
架构师技术联盟
12-05 4530
　　随着数据的爆炸式增长，各个领域对计算机硬件的处理能力有了更高的要求。相比于CPU和GPU等计算设备的快速发展，传统的以太网领域发展明显滞后并逐渐成为性能瓶颈。大量产品...
谈谈高性能RDMA网络优势和实践
架构师技术联盟
04-25 1233
　　随着数据的爆炸式增长，各个领域对计算机硬件的处理能力有了更高的要求。相比于CPU和GPU等计算设备的快速发展，传统的以太网领域发展明显滞后并逐渐成为性能瓶颈。大量产品...
探索高性能网络通信：RDMA编程实例源码推荐
gitblog_09706的博客
10-17 1055
探索高性能网络通信：RDMA编程实例源码推荐 【下载地址】RDMA编程实例源码rdma_cmAPI 本仓库提供了一个RDMA（远程直接内存访问）编程实例的源码，使用的是rdma_cm API。RDMA是一种高性能网络通信技术，允许数据在网络中的不同节点之间直接传输，而无需通过CPU的介入，从而显著提高了数据传输的效率和性...
技术解析丨加速高性能计算，RDMA 在分布式存储中的性能优化实践
YAN_RONG_TECHNOLOGY的博客
10-28 1028
随着 GPU 的快速迭代和大规模数据集的不断增长，为了确保整体 AI 训练系统的效率，存储网络也需要不断进化，对 RDMA 的需求变得愈发迫切。凭借低延迟和高吞吐量的优势，RDMA 现已成为 AI 存储系统中的重要技术选项。然而，与传统 TCP socket 通过简单调用 API 即可完成网络通信的方式不同，RDMA 要求用户处理更多通信细节，这无疑增加了其使用的复杂性。在本篇文章中，我们将分享焱融科技在 RDMA 网络技术支持方面的实践经验，并探讨 RDMA 性能调优的实用技巧，为企业存储系统性能提供参考
高性能网络编程新里程：RDMA Tutorial
gitblog_00008的博客
04-20 562
高性能网络编程新里程：RDMA Tutorial 项目地址:https://gitcode.com/gh_mirrors/rd/RDMA-Tutorial 教程是由开发者jcxue创建的一个开源项目，它旨在帮助程序员和系统管理员深入理解并掌握使用RDMA进行高性能网络编程的技术。RDMA是一种革命性的通信方式，允许不同的计算节点直接访问对方内存，显著降低了传统网络I/O的开销，提升了数据传输速度。...
大规模 AI 高性能网络的设计与实践
2301_82040283的博客
01-26 1785
欢迎来到百度智能云云智公开课 AI 大底座的系列分享。今天晚上由我来开启本轮系列分享的第一场，聚焦百度智能云 AI 大底座的关键技术——大规模 AI 高性能网络。 本次分享我们分为三个小节。首先从大模型的分布式训练出发，分析大模型训练对网络的核心需求。然后基于这些需求讨论 AIPod 高性能网络的设计。最后将讨论一些做大模型训练的实践经验。 1. 大模型训练对网络的要求 我们先来聊聊大模型训练对网络的需求。 最近半年以来大模型持续火爆。虽然关于大模型的发展与应用还有很多的争论，但可以肯定的是，大模型
基于RDMA的云服务能力实践与探索
wjw7869的专栏
04-02 1400
RDMA扩展网卡的能力，不需要CPU参与，就可以实现在两台通信的主机间完成内存数据复制操作。RDMA提供了三种技术规范实现方式，分别是IB (Infiniband), iWARP (Internet Wide Area RDMA Protocol) 和RoCE (RDMA over Converged Ethernet)。三种实现都支持IBTA (InfiniBand Trade Association) 制定的RDMA Verbs原语和数据类型，提供统一的业务编程接口供用户使用，达到业务无缝切换。
彻底解决大模型训练集群的网络哈希冲突，百度百舸的高性能网络 HPN 落地实践
2301_82040283的博客
07-03 1249
百度百舸的 95% 物理网络「带宽有效性」原来是这样做到的
构建高性能网络通信应用：RDMA编程实战步步为营
随着信息技术的快速发展，高性能网络通信需求日益增长，远程直接内存访问（RDMA）技术因其高效率和低延迟特性逐渐成为研究热点。本文深入探讨了RDMA的基础知识、编程模型、架构以及实际应用案例。首先介绍RDMA的基本...
RDMA与传统网络通信深度对比：分析性能优势及应用场景
RDMA技术作为一种革新性的数据传输技术，正逐渐成为提升网络通信性能的关键技术。本论文首先对RDMA技术进行了全面的概述，并与传统网络通信机制进行了对比，突出了RDMA在减少CPU和内存使用、降低延迟以及提高吞吐量...
机器人“跨协议对话”秘籍：EtherNet IP转PROFINET网关应用实录
bjbxkj的博客
04-29 665
由于两种协议在通信标准和数据格式上存在差异，导致机器人手臂无法与现场的终端控制器直接通信，设备之间的数据交换无法顺利进行，严重影响了生产线的整体效率。通过该网关的及时引入，我们避免了大规模设备改造带来的高昂成本和生产延误风险，显著提高了设备协作效率和生产线整体性能，获得了生产部门的一致认可。针对这一问题，我们工程师团队经过详细分析和现场测试，决定采用EtherNet/IP转PROFINET通信协议网关（倍讯BX-606-EIP）来实现快速、稳定的协议转换。接受控制器主动发送的指令及数据请求。
Nginx核心功能——nginx代理
2401_88768957的博客
05-01 1228
主要作用是将客户端的请求转发给目标服务器，并将响应返回给客户端Nginx 的 正向代理 充当客户端的“中间人”，它赋予开发者精准控制URL的能力，让请求的流转不再受限于物理路径，而是通过逻辑规则灵活适配业务需求。Nginx的七层(应用层)反向代理基于HTTP/HTTPS 协议。Nginx的四层(网络层)反向代理基于 TCP/UDP 协议，改成break标记，使用浏览器请求，
网络原理初识
2401_83526138的博客
04-29 608
物理层规定了网络通信中一些硬件设施（网线，光纤，WIFI）的要求。
指定的网络名不再可用0x00000040原因分析及解决方法
电脑技术分享网的博客
04-30 708
如：用户是属于修复别人共享给我的打印机（客户端）或前面两种都是的两个选项场景，勾选修复了【共享主机】更新补丁选项，则可能会出现打印机报错的情况。出现此类问题时，可再次点击重新扫描，找到其中的【共享主机】更新补丁进行还原，即可解决大部分别人共享给我的打印机常见错误修复。2、物理连接问题：如果使用的是网络打印机，确保打印机与网络的连接没有问题，比如网线连接正常，打印机的网络设置正确等。可快速扫描当前连接打印机需要的驱动，在扫描出的打印机驱动中可选择相关打印机驱动版本进行修复安装。
wireshark抓包也能被篡改？
最新发布
ailx10
05-03 389
本身并不能修改数据包，但是tcprewrite 可以修改数据包，然后通过tcpreplay 进行重放，这个时候wireshark抓的包，就是被篡改后的了。ailx10网络安全优秀回答者互联网行业 安全攻防员去咨询步骤一：安装 libpcap-dev步骤二：下载源代码，并编译安装步骤三：准备pcap包，以访问知乎的pcap包为例，记住篡改前的信息步骤四：跟着ailx10，开干修改pcap包的源IP地址，从192.168.0.108改成1.1.1.1。
ActiveMQ 性能优化与网络配置实战（一）
qq_42190530的博客
05-01 1225
NIO 与 BIO 模型选择、协议优化（OpenWire/Stomp）、生产者限流与消费者预取策略。
局域网视频会议软件BeeWorks Meet
weixin_53855915的博客
04-29 481
视频会议是企业协作的重要工具，它可以支持日常会议、异地协作等内部沟通需求，节省时间和成本，在与合作伙伴沟通方面，视频会议能助力远程沟通、项目展示及商务谈判，提高合作效率。相比传统的公有云视频会议服务，私有化部署的视频会议系统在安全性、可控性、定制化和成本效益等方面具有显著优势，为企业内部使用提供了强大的支持。BeeWorks音视频会议系统支持多种类型的会议，如网络会议、在线培训、远程招聘等。提供全面的参会管理功能，如添加/删除参会人、控制发言、点名、举手、投票、签到等，方便会议组织者进行高效管理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Hi20240217

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值