如何用C++优化网络IO性能 epoll与io_uring使用指南

#include <sys/epoll.h>
#include <iostream>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

int main() {
    int epoll_fd = epoll_create1(0);
    if (epoll_fd == -1) {
        perror("epoll_create1");
        return 1;
    }

    // 创建一个socket (假设已经创建并绑定)
    int socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    // ... (绑定socket, 监听socket)

    // 设置socket为非阻塞模式
    int flags = fcntl(socket_fd, F_GETFL, 0);
    fcntl(socket_fd, F_SETFL, flags | O_NONBLOCK);

    epoll_event event;
    event.events = EPOLLIN | EPOLLET; // 边缘触发模式
    event.data.fd = socket_fd;

    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, socket_fd, &event) == -1) {
        perror("epoll_ctl: add socket_fd");
        close(socket_fd);
        close(epoll_fd);
        return 1;
    }

    epoll_event events[10];
    while (true) {
        int nfds = epoll_wait(epoll_fd, events, 10, -1); // -1表示无限期等待
        if (nfds == -1) {
            perror("epoll_wait");
            break;
        }

        for (int i = 0; i < nfds; ++i) {
            if (events[i].data.fd == socket_fd) {
                // 新连接到来
                sockaddr_in client_addr;
                socklen_t client_len = sizeof(client_addr);
                int new_socket = accept(socket_fd, (sockaddr*)&client_addr, &client_len);
                if (new_socket == -1) {
                    perror("accept");
                    continue;
                }

                // 设置新连接为非阻塞模式
                flags = fcntl(new_socket, F_GETFL, 0);
                fcntl(new_socket, F_SETFL, flags | O_NONBLOCK);

                // 将新连接添加到epoll中
                event.events = EPOLLIN | EPOLLET;
                event.data.fd = new_socket;
                if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, new_socket, &event) == -1) {
                    perror("epoll_ctl: add new_socket");
                    close(new_socket);
                }
            } else if (events[i].events & EPOLLIN) {
                // socket可读
                int current_socket = events[i].data.fd;
                char buffer[1024];
                ssize_t count;

                while ((count = recv(current_socket, buffer, sizeof(buffer), 0)) > 0) {
                    // 处理数据
                    std::cout << "Received: " << std::string(buffer, count) << std::endl;
                }

                if (count == -1) {
                    if (errno != EAGAIN) {
                        perror("recv");
                        close(current_socket);
                        epoll_ctl(epoll_fd, EPOLL_CTL_DEL, current_socket, NULL);
                    }
                } else if (count == 0) {
                    // 连接关闭
                    std::cout << "Connection closed by peer." << std::endl;
                    close(current_socket);
                    epoll_ctl(epoll_fd, EPOLL_CTL_DEL, current_socket, NULL);
                }
            } else if (events[i].events & (EPOLLERR | EPOLLHUP)) {
                // 发生错误或连接关闭
                std::cerr << "Epoll error on socket: " << events[i].data.fd << std::endl;
                close(events[i].data.fd);
                epoll_ctl(epoll_fd, EPOLL_CTL_DEL, events[i].data.fd, NULL);
            }
        }
    }

    close(epoll_fd);
    close(socket_fd);

    return 0;
}

#include <iostream>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <liburing.h>
#include <sys/stat.h>

#define BUF_SIZE 4096

int main() {
    io_uring ring;
    io_uring_queue_init(1024, &ring, 0); // 初始化io_uring

    int fd = open("test.txt", O_RDONLY);
    if (fd < 0) {
        perror("open");
        return 1;
    }

    char *buf = new char[BUF_SIZE];
    memset(buf, 0, BUF_SIZE);

    io_uring_sqe *sqe = io_uring_get_sqe(&ring); // 获取SQE
    if (!sqe) {
        std::cerr << "Could not get SQE" << std::endl;
        close(fd);
        delete[] buf;
        io_uring_queue_exit(&ring);
        return 1;
    }

    io_uring_prep_read(sqe, fd, buf, BUF_SIZE, 0); // 准备读取操作
    io_uring_sqe_set_data(sqe, buf); // 将buf指针与SQE关联

    io_uring_submit(&ring); // 提交请求

    io_uring_cqe *cqe;
    io_uring_wait_cqe(&ring, &cqe); // 等待完成

    if (cqe->res < 0) {
        std::cerr << "Read failed: " << strerror(-cqe->res) << std::endl;
    } else {
        std::cout << "Read " << cqe->res << " bytes: " << buf << std::endl;
    }

    io_uring_cqe_seen(&ring, cqe); // 标记CQE已处理

    close(fd);
    delete[] buf;
    io_uring_queue_exit(&ring); // 退出io_uring

    return 0;
}