讲讲在Libuv中使用Io_Uring

本文转载自微信公众号「编程杂技  」，作者theanarkh 。转载本文请联系编程杂技公众号。

网站建设哪家好，找创新互联！专注于网页设计、网站建设、微信开发、重庆小程序开发公司、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了龙凤免费建站欢迎大家使用！

本文介绍如果在Libuv中使用io_uring。逻辑：

1 申请一个io_uring对应的fd。

2 初始化一个poll handle，封装1中的fd。

3 注册到Libuv的epoll中。

4 读取文件列表，给io_uring提交请求

5 io_uring完成，1中的fd可读，从而epoll返回。

6 Libuv的poll io阶段执行回调。

7 回调里获取io_uring的任务完成列表，拿到每个任务关联的请求，执行回调。

 
 
 
    
  
  
  
  1. #include 
    2. 
  
  
  
  2. #include 
    3. 
  
  
  
  3. #include 
    4. 
  
  
  
  4. #include 
    5. 
  
  
  
  5. #include 
    6. 
  
  
  
  6. #include 
    7. 
  
  
  
  7. #include 
    8. 
  
  
  
  8. #include 
    9. 
  
  
  
  9. #define QUEUE_DEPTH 1
    10. 
  
  
  
  10. #define BLOCK_SZ    1024
    11. 
  
  
  
  11. 
  
  
  
  12. // 前向声明
    13. 
  
  
  
  13. struct file_info;
    14. 
  
  
  
  14. // 定义回调
    15. 
  
  
  
  15. typedef void (*file_callback)(struct file_info*);
    16. 
  
  
  
  16. 
  
  
  
  17. // 管理一个文件读取请求的结构体
    18. 
  
  
  
  18. struct file_info {
    19. 
  
  
  
  19.     // 文件大小
    20. 
  
  
  
  20.     off_t file_sz;
    21. 
  
  
  
  21.     // 回调
    22. 
  
  
  
  22.     file_callback cb;
    23. 
  
  
  
  23.     // 读取的大小
    24. 
  
  
  
  24.     int count;
    25. 
  
  
  
  25.     // 文件名
    26. 
  
  
  
  26.     char *name;
    27. 
  
  
  
  27.     // 读取的数据
    28. 
  
  
  
  28.     struct iovec iovecs[];     
    29. 
  
  
  
  29. };
    30. 
  
  
  
  30. 
  
  
  
  31. // 获取文件大小
    32. 
  
  
  
  32. off_t get_file_size(int fd) {
    33. 
  
  
  
  33.     struct stat st;
    34. 
  
  
  
  34. 
  
  
  
  35.     if(fstat(fd, &st) < 0) {
    36. 
  
  
  
  36.         perror("fstat");
    37. 
  
  
  
  37.         return -1;
    38. 
  
  
  
  38.     }
    39. 
  
  
  
  39.     if (S_ISBLK(st.st_mode)) {
    40. 
  
  
  
  40.         unsigned long long bytes;
    41. 
  
  
  
  41.         if (ioctl(fd, BLKGETSIZE64, &bytes) != 0) {
    42. 
  
  
  
  42.             perror("ioctl");
    43. 
  
  
  
  43.             return -1;
    44. 
  
  
  
  44.         }
    45. 
  
  
  
  45.         return bytes;
    46. 
  
  
  
  46.     } else if (S_ISREG(st.st_mode))
    47. 
  
  
  
  47.         return st.st_size;
    48. 
  
  
  
  48. 
  
  
  
  49.     return -1;
    50. 
  
  
  
  50. }
    51. 
  
  
  
  51. 
  
  
  
  52. // 向内核提交一个请求
    53. 
  
  
  
  53. int submit_read_request(char *file_path, file_callback cb, struct io_uring *ring) {
    54. 
  
  
  
  54.     // 打开文件
    55. 
  
  
  
  55.     int file_fd = open(file_path, O_RDONLY);
    56. 
  
  
  
  56.     if (file_fd < 0) {
    57. 
  
  
  
  57.         perror("open");
    58. 
  
  
  
  58.         return 1;
    59. 
  
  
  
  59.     }
    60. 
  
  
  
  60.     // 获取大小
    61. 
  
  
  
  61.     off_t file_sz = get_file_size(file_fd);
    62. 
  
  
  
  62.     off_t bytes_remaining = file_sz;
    63. 
  
  
  
  63.     int current_block = 0;
    64. 
  
  
  
  64.     int blocks = (int) file_sz / BLOCK_SZ;
    65. 
  
  
  
  65.     if (file_sz % BLOCK_SZ) blocks++;
    66. 
  
  
  
  66.     // 申请内存
    67. 
  
  
  
  67.     struct file_info *fi = malloc(sizeof(*fi) + (sizeof(struct iovec) * blocks));
    68. 
  
  
  
  68.     // 保存文件名
    69. 
  
  
  
  69.     fi->name = file_path;
    70. 
  
  
  
  70.     // 计算和申请保存文件内容的内存
    71. 
  
  
  
  71.     while (bytes_remaining) {
    72. 
  
  
  
  72.         // 剩下的大小
    73. 
  
  
  
  73.         off_t bytes_to_read = bytes_remaining;
    74. 
  
  
  
  74.         // 一个buffer最大保存BLOCK_SZ大小
    75. 
  
  
  
  75.         if (bytes_to_read > BLOCK_SZ)
    76. 
  
  
  
  76.             bytes_to_read = BLOCK_SZ;
    77. 
  
  
  
  77.         // 记录buffer大小
    78. 
  
  
  
  78.         fi->iovecs[current_block].iov_len = bytes_to_read;
    79. 
  
  
  
  79.         // 申请内存
    80. 
  
  
  
  80.         void *buf;
    81. 
  
  
  
  81.         if( posix_memalign(&buf, BLOCK_SZ, BLOCK_SZ)) {
    82. 
  
  
  
  82.             perror("posix_memalign");
    83. 
  
  
  
  83.             return 1;
    84. 
  
  
  
  84.         }
    85. 
  
  
  
  85.         // 记录内存地址
    86. 
  
  
  
  86.         fi->iovecs[current_block].iov_base = buf;
    87. 
  
  
  
  87.         // 下一块
    88. 
  
  
  
  88.         current_block++;
    89. 
  
  
  
  89.         // 更新剩下的大小
    90. 
  
  
  
  90.         bytes_remaining -= bytes_to_read;
    91. 
  
  
  
  91.     }
    92. 
  
  
  
  92.     // 保存文件大小
    93. 
  
  
  
  93.     fi->file_sz = file_sz;
    94. 
  
  
  
  94.     // 获取一个io_uring的请求结构体
    95. 
  
  
  
  95.     struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
    96. 
  
  
  
  96.     // 填充请求
    97. 
  
  
  
  97.     io_uring_prep_readv(sqe, file_fd, fi->iovecs, blocks, 0);
    98. 
  
  
  
  98.     // 保存请求上下文，响应的时候用
    99. 
  
  
  
  99.     io_uring_sqe_set_data(sqe, fi);
    100. 
  
  
  
  100.     // 保存回调
    101. 
  
  
  
  101.     fi->cb = cb;
    102. 
  
  
  
  102.     // 提交请求给内核
    103. 
  
  
  
  103.     io_uring_submit(ring);
    104. 
  
  
  
  104. 
  
  
  
  105.     return 0;
    106. 
  
  
  
  106. }
    107. 
  
  
  
  107. 
  
  
  
  108. // io_uring相关的结构体
    109. 
  
  
  
  109. struct io_uring_info {
    110. 
  
  
  
  110.   int fd;
    111. 
  
  
  
  111.   int32_t pending;
    112. 
  
  
  
  112.   struct io_uring ring;
    113. 
  
  
  
  113.   uv_poll_t poll_handle;
    114. 
  
  
  
  114. };
    115. 
  
  
  
  115. 
  
  
  
  116. // io_uring完成任务后，Libuv执行的回调
    117. 
  
  
  
  117. void uv__io_uring_done(uv_poll_t* handle, int status, int events) {
    118. 
  
  
  
  118.     struct io_uring* ring;
    119. 
  
  
  
  119.     struct io_uring_info* io_uring_data;
    120. 
  
  
  
  120.     struct io_uring_cqe* cqe;
    121. 
  
  
  
  121.     struct file_info* req;
    122. 
  
  
  
  122.     // 获取Libuv中保存的io_uring信息
    123. 
  
  
  
  123.     io_uring_data = uv_default_loop()->data;
    124. 
  
  
  
  124.     ring = &io_uring_data->ring;
    125. 
  
  
  
  125.     // 处理每一个完成的请求
    126. 
  
  
  
  126.     while (1) { 
    127. 
  
  
  
  127.         io_uring_peek_cqe(ring, &cqe);
    128. 
  
  
  
  128. 
  
  
  
  129.         if (cqe == NULL)
    130. 
  
  
  
  130.             break;
    131. 
  
  
  
  131.         // 全部处理完则注销事件
    132. 
  
  
  
  132.         if (--io_uring_data->pending == 0)
    133. 
  
  
  
  133.            uv_poll_stop(handle);
    134. 
  
  
  
  134.         // 拿到请求上下文
    135. 
  
  
  
  135.         req = (void*) (uintptr_t) cqe->user_data;
    136. 
  
  
  
  136.         // 记录读取的大小
    137. 
  
  
  
  137.         req->count = cqe->res;
    138. 
  
  
  
  138. 
  
  
  
  139.         io_uring_cq_advance(ring, 1);
    140. 
  
  
  
  140.         // 执行回调
    141. 
  
  
  
  141.         req->cb(req);
    142. 
  
  
  
  142.     }
    143. 
  
  
  
  143.     // 处理完则退出
    144. 
  
  
  
  144.     if (io_uring_data->pending == 0)
    145. 
  
  
  
  145.         uv_stop(uv_default_loop());
    146. 
  
  
  
  146. }
    147. 
  
  
  
  147. 
  
  
  
  148. // 文件读取后的业务回调
    149. 
  
  
  
  149. void filedone(struct file_info* info) {
    150. 
  
  
  
  150.     printf("读取的大小：%d，文件信息：%s => %d\n", (int)info->count, info->name, (int)info->file_sz);}int main(int argc, char *argv[]) {
    151. 
  
  
  
  151. 
  
  
  
  152.     if (argc < 2) {
    153. 
  
  
  
  153.         fprintf(stderr, "请输入文件名称\n");
    154. 
  
  
  
  154.         return 1;
    155. 
  
  
  
  155.     }
    156. 
  
  
  
  156.     // 申请一个io_uring相关的结构体
    157. 
  
  
  
  157.     struct io_uring_info *io_uring_data = malloc(sizeof(*io_uring_data));
    158. 
  
  
  
  158.     // 初始化io_uring
    159. 
  
  
  
  159.     io_uring_queue_init(1, &io_uring_data->ring, 0);
    160. 
  
  
  
  160.     // 初始化poll handle，保存监听的fd
    161. 
  
  
  
  161.     uv_poll_init(uv_default_loop(), &io_uring_data->poll_handle, io_uring_data->ring.ring_fd);
    162. 
  
  
  
  162.     // 注册事件和回调
    163. 
  
  
  
  163.     uv_poll_start(&io_uring_data->poll_handle, UV_READABLE, uv__io_uring_done);
    164. 
  
  
  
  164.     // 保存io_uring的上下文在loop中
    165. 
  
  
  
  165.     uv_default_loop()->data = (void *)io_uring_data;
    166. 
  
  
  
  166.     // 处理每一个文件
    167. 
  
  
  
  167.     for (int i = 1; i < argc; i++) {
    168. 
  
  
  
  168.         submit_read_request(argv[i], filedone, &io_uring_data->ring);
    169. 
  
  
  
  169.         io_uring_data->pending++;
    170. 
  
  
  
  170.     }
    171. 
  
  
  
  171.     // 开始事件循环
    172. 
  
  
  
  172.     uv_run(uv_default_loop(), UV_RUN_DEFAULT);
    173. 
  
  
  
  173.     // 退出
    174. 
  
  
  
  174.     uv_loop_close(uv_default_loop());
    175. 
  
  
  
  175.     io_uring_queue_exit(&io_uring_data->ring);
    176. 
  
  
  
  176.     return 0;
    177. 
  
  
  
  177. }
    178.

编译过程

1 git clone https://github.com/axboe/liburing.git。执行./configure && make -j2 && sudo make install(make j2开启两个线程编译，根据自己的核数定)。

2 git clone https://github.com/libuv/libuv.git。执行./autogen.sh && ./configure && make -j2 && sudo make install。

3 安装完依赖后新建test.cc。然后编译 gcc -xc test2.cc -luring -luv(xc指定按c语言编译，c++的话限制不一样，会报错)。

4 新建两个测试文件hello.cc和world.cc 。执行 ./a.out hello.cc world.cc。

5 输出

 
 
 
    
  
  
  
  1. 读取的大小：6997，文件信息：hello.cc => 6997
    2. 
  
  
  
  2. 读取的大小：11019，文件信息：world.cc => 11019
    3.

代码仓库：https://github.com/theanarkh/learn-io_uring。

可以参考

1.https://github.com/shuveb/io_uring-by-example/blob/master/03_cat_liburing/main.c

2 https://github.com/libuv/libuv/pull/2322

网页名称：讲讲在Libuv中使用Io_Uring
当前地址：http://www.shufengxianlan.com/qtweb/news3/214103.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

云服务器知识

各行业网站

免备案空间　　 　响应式网站　　 　光华村机房　　 　什邡网站建设　　 　网站搜索引擎优化　　 　广告媒介投放　　 　成都app开发　　 　成都ssl证书认证　　 　成都网站推广　　 　外贸网站建设方案　　 　眉山网站建设　　 　成都ssl证书申请　　 　成都西信服务器托管　　 　公路打桩机　　 　租用服务器　　 　西信服务器托管　　 　网站建设策划方案　　 　手机网站设计　　 　成都服务器运维　　 　江油网站建设