Chinaunix首页 | 论坛 | 博客

嵌入式Linux点滴

首页　| 　博文目录　| 　关于我

qxhgd

  • 博客访问： 972604
  • 博文数量： 403
  • 博客积分： 27
  • 博客等级： 民兵
  • 技术积分： 165
  • 用 户 组： 普通用户
  • 注册时间： 2011-12-25 22:20
文章分类

全部博文（403）

文章存档

2016年（3）

2015年（16）

2014年（163）

2013年（222）

我的朋友
最近访客
推荐博文
相关博文
LibEvent代码阅读--多缓冲区和零拷贝技术

分类： LINUX

2015-02-12 16:15:15

原文地址：LibEvent代码阅读--多缓冲区和零拷贝技术 作者：gongping11

最近项目赶着发版本，连续好几天通宵赶工，瓶颈出现在了性能问题，各种方案验证和修订。周末闲下来还是对之前学习的libevent进行总结。
在libevent的报文收发处理过程中采用了一系列提高收发性能的技术，其中多缓冲区的接收和发送以及零拷贝技术等，本篇主要分析这些技术在libevent中的运用。

首先简要的介绍一下两种技术:
多缓存的收据发送和接收:

点击(此处)折叠或打开

  1. struct iovec {
  2.     ptr_t iov_base; /* Starting address */
  3.     size_t iov_len; /* Length in bytes */
  4. };

  6. int readv(int fd, const struct iovec *vector, int count);
  7. int writev(int fd, const struct iovec *vector, int count);
其中的iovec是指一个缓冲区，包含了数据区的地址和对应的长度，在两个函数中的count是指iovec的个数。这种多缓冲区的发送和接收操作性能相对更好。而iovec需要在使用前分配好相关的内存空间。

零拷贝技术：
零拷贝能够减少数据之间无效的数据拷贝，而直接进行数据的发送，通常在数据发送的过程中使用,特别是在文件发送的过程中被经常使用。通常情况下要将文件a.txt中的内容发送出去，需要进行如下的操作:
读取文件内容: read(),然后发送读取的内容send()。因此一个完整的过程会出现一个读取再发送的操作，往往文件的IO操作是相对费时的操作，因此零拷贝技术实际上就是较少了read()的处理过程，即在发送数据前不需要进行文件的读取操作，这样相对而言就会提高处理的性能。关于零拷贝的技术有很多方式，这里主要介绍sendfile和mmap.
其中的mmap是采用映射的方式将文件内容映射到内存中，在发送报文时直接读取内存中的内容，这样就能提高发送效率。
sendfile则是直接将读取到文件fd的内容发送到输出的fd中，也不需要文件读取的过程，性能也会提高。
以上两种处理方式实际上都是内核协助完成。

点击(此处)折叠或打开

  1. void *mmap(void *start,size_t length,int prot,int flags,int fd,off_t offsize）;

  3. ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count);
Libevent中多缓存的分析
关于多缓冲区的数据发送和接收主要是在报文的接收和发送过程中使用，多缓冲区减少了调用send和recv的次数。

点击(此处)折叠或打开

  1. /* 如果支持多缓冲区的写操作 */
  2. int
  3. evbuffer_write_iovec(struct evbuffer *buffer, evutil_socket_t fd,
  4.     ev_ssize_t howmuch)
  5. {
  6.     IOV_TYPE iov[NUM_WRITE_IOVEC];
  7.     struct evbuffer_chain *chain = buffer->first;
  8.     int n, i = 0;

  10.     if (howmuch < 0)
  11.         return -1;

  13.     ASSERT_EVBUFFER_LOCKED(buffer);
  14.     /* XXX make this top out at some maximal data length? if the
  15.      * buffer has (say) 1MB in it, split over 128 chains, there's
  16.      * no way it all gets written in one go. */
  17.      /* 从evbuffer中将对应的数据拷贝出来 */
  18.     while (chain != NULL && i < NUM_WRITE_IOVEC && howmuch) {
  19. #ifdef USE_SENDFILE
  20.         /* we cannot write the file info via writev */
  21.         if (chain->flags & EVBUFFER_SENDFILE)
  22.             break;
  23. #endif
  24.         /*iov[i].iov_base XXX的含义*/
  25.         iov[i].IOV_PTR_FIELD = (void *) (chain->buffer + chain->misalign);
  26.         if ((size_t)howmuch >= chain->off) {
  27.             /* XXXcould be problematic when windows supports mmap*/
  28.             /*iov[i++].iov_len是指长度*/
  29.             iov[i++].IOV_LEN_FIELD = (IOV_LEN_TYPE)chain->off;
  30.             howmuch -= chain->off;
  31.         } else {
  32.             /* XXXcould be problematic when windows supports mmap*/
  33.             iov[i++].IOV_LEN_FIELD = (IOV_LEN_TYPE)howmuch;
  34.             break;
  35.         }
  36.         chain = chain->next;
  37.     }
  38.     if (! i)
  39.         return 0;
  40.     /* 采用多缓冲区发送，因此fd应该是发送的接口 */
  41.     n = writev(fd, iov, i);

  43.     return (n);
  44. }
接收报文的的处理过程:

点击(此处)折叠或打开

  1. int
  2. evbuffer_read(struct evbuffer *buf, evutil_socket_t fd, int howmuch)
  3. {
  4.     struct evbuffer_chain **chainp;
  5.     int n;
  6.     int result;

  8.     int nvecs, i, remaining;

  10.     EVBUFFER_LOCK(buf);

  12.     if (buf->freeze_end) {
  13.         result = -1;
  14.         goto done;
  15.     }

  17.     n = get_n_bytes_readable_on_socket(fd);
  18.     if (n <= 0 || n > EVBUFFER_MAX_READ)
  19.         n = EVBUFFER_MAX_READ;
  20.     if (howmuch < 0 || howmuch > n) /* 读写长度 */
  21.         howmuch = n;

  23.     /* Since we can use iovecs, we're willing to use the last
  24.      * NUM_READ_IOVEC chains. */
  25.     if (_evbuffer_expand_fast(buf, howmuch, NUM_READ_IOVEC) == -1) {
  26.         result = -1;
  27.         goto done;
  28.     } else {
  29.         IOV_TYPE vecs[NUM_READ_IOVEC];
  30.         /* 实际是完成数据空间的预分配，即vecs空间的分配，4个vecs的空间，chainp是缓冲区的开始地址 */
  31.         nvecs = _evbuffer_read_setup_vecs(buf, howmuch, vecs,
  32.          NUM_READ_IOVEC, &chainp, 1);

  34.         /* 调用readv，采用多缓冲区的读写方式，linux的高级套接字，n是实际返回的长度 */
  35.         n = readv(fd, vecs, nvecs);
  36.     }

  38.     if (n == -1) {
  39.         result = -1;
  40.         goto done;
  41.     }
  42.     if (n == 0) {
  43.         result = 0;
  44.         goto done;
  45.     }

  47.     remaining = n;
  48.     /* nvecs是指多个缓冲区，但是不一定有那么多的数据 */
  49.     for (i=0; i < nvecs; ++i) {
  50.         /* 获取chain的长度 */
  51.         ev_ssize_t space = (ev_ssize_t) CHAIN_SPACE_LEN(*chainp);
  52.         if (space < remaining) { /* 若长度不够 */
  53.             (*chainp)->off += space; /* 则当前chain的内存使用完毕 */
  54.             remaining -= (int)space; /* 剩下的内存空间 */
  55.         } else {
  56.             (*chainp)->off += remaining; /* 当前空间已经足够 */
  57.             buf->last_with_datap = chainp;
  58.             break;
  59.         }
  60.         chainp = &(*chainp)->next;
  61.     }

  63.     /* 更新当前实际的有效长度 */
  64.     buf->total_len += n;
  65.     buf->n_add_for_cb += n;

  67.     /* Tell someone about changes in this buffer */
  68.     evbuffer_invoke_callbacks(buf);
  69.     result = n;
  70. done:
  71.     EVBUFFER_UNLOCK(buf);
  72.     return result;
  73. }
设置缓存队列的过程如下所示:

点击(此处)折叠或打开

  1. int
  2. _evbuffer_read_setup_vecs(struct evbuffer *buf, ev_ssize_t howmuch,
  3.     struct evbuffer_iovec *vecs, int n_vecs_avail,
  4.     struct evbuffer_chain ***chainp, int exact)
  5. {
  6.     struct evbuffer_chain *chain;
  7.     struct evbuffer_chain **firstchainp;
  8.     size_t so_far;
  9.     int i;
  10.     ASSERT_EVBUFFER_LOCKED(buf);

  12.     if (howmuch < 0)
  13.         return -1;

  15.     so_far = 0;
  16.     /* Let firstchain be the first chain with any space on it */
  17.     /* 从当前有数据的位置保存 */
  18.     firstchainp = buf->last_with_datap;
  19.     if (CHAIN_SPACE_LEN(*firstchainp) == 0) {
  20.         firstchainp = &(*firstchainp)->next;
  21.     }

  23.     chain = *firstchainp;
  24.     for (i = 0; i < n_vecs_avail && so_far < (size_t)howmuch; ++i) {
  25.         /* 获取当前chain可用的内存大小 */
  26.         size_t avail = (size_t) CHAIN_SPACE_LEN(chain);
  27.         if (avail > (howmuch - so_far) && exact) /* 当前内存足够存放 */
  28.             avail = howmuch - so_far;
  29.         /* vecs的基地址 */
  30.         vecs[i].iov_base = CHAIN_SPACE_PTR(chain);
  31.         vecs[i].iov_len = avail;
  32.         so_far += avail;
  33.         
  34.         chain = chain->next;
  35.     }

  37.     *chainp = firstchainp;
  38.     return i;
  39. }
在接收的过程中只需要设置好对应的缓存区大小以及对应的缓存地址，然后调用readv进行报文的接收。

Libevent中零拷贝的实现
关于零拷贝技术在libevent中主要体现在用于文件发送的过程中，提供了发送文件内容的接口:

点击(此处)折叠或打开

  1. int
  2. evbuffer_add_file(struct evbuffer *outbuf, int fd,
  3.     ev_off_t offset, ev_off_t length)
其中outbuf主要用于输出的缓存，fd是指需要被发送的文件描述符，offset是文件的偏移量，length是指需要发送的长度，其中outbuf是在bufferevent中的output。

点击(此处)折叠或打开

  1. int
  2. evbuffer_add_file(struct evbuffer *outbuf, int fd,
  3.     ev_off_t offset, ev_off_t length)
  4. {
  5. #if defined(USE_SENDFILE) || defined(_EVENT_HAVE_MMAP)
  6.     struct evbuffer_chain *chain;
  7.     struct evbuffer_chain_fd *info;
  8. #endif
  9. #if defined(USE_SENDFILE)
  10.     int sendfile_okay = 1;
  11. #endif
  12.     int ok = 1;

  14. #if defined(USE_SENDFILE)
  15.     if (use_sendfile) {
  16.         EVBUFFER_LOCK(outbuf);
  17.         sendfile_okay = outbuf->flags & EVBUFFER_FLAG_DRAINS_TO_FD;
  18.         EVBUFFER_UNLOCK(outbuf);
  19.     }

  21.     if (use_sendfile && sendfile_okay) {
  22.         /* 1K大小，分配一个chain */
  23.         chain = evbuffer_chain_new(sizeof(struct evbuffer_chain_fd));
  24.         if (chain == NULL) {
  25.             event_warn("%s: out of memory", __func__);
  26.             return (-1);
  27.         }
  28.         
  29.      /* 设置chain的属性 */
  30.         chain->flags |= EVBUFFER_SENDFILE | EVBUFFER_IMMUTABLE;
  31.         chain->buffer = NULL;    /* no reading possible，在sendfile中不需要buffer */
  32.         chain->buffer_len = length + offset;
  33.         chain->off = length;
  34.         chain->misalign = offset;

  36.         info = EVBUFFER_CHAIN_EXTRA(struct evbuffer_chain_fd, chain);
  37.         /* 避免拷贝数据，保存的是文件的fd，后面获取该fd进行发送操作 */
  38.         info->fd = fd;

  40.         EVBUFFER_LOCK(outbuf);
  41.         if (outbuf->freeze_end) {
  42.             mm_free(chain);
  43.             ok = 0;
  44.         } else {
  45.             /* 添加到output吧 */
  46.             outbuf->n_add_for_cb += length;
  47.             evbuffer_chain_insert(outbuf, chain);
  48.         }
  49.     } else
  50. #endif
  51. #if defined(_EVENT_HAVE_MMAP)
  52.     if (use_mmap) {
  53.         /* 内存映射，将文件映射到内存中,采用mmap的方式减少内存拷贝 */
  54.         void *mapped = mmap(NULL, length + offset, PROT_READ,
  55. #ifdef MAP_NOCACHE
  56.          MAP_NOCACHE |
  57. #endif
  58. #ifdef MAP_FILE
  59.          MAP_FILE |
  60. #endif
  61.          MAP_PRIVATE,
  62.          fd, 0);
  63.         /* some mmap implementations require offset to be a multiple of
  64.          * the page size. most users of this api, are likely to use 0
  65.          * so mapping everything is not likely to be a problem.
  66.          * TODO(niels): determine page size and round offset to that
  67.          * page size to avoid mapping too much memory.
  68.          */
  69.         if (mapped == MAP_FAILED) {
  70.             event_warn("%s: mmap(%d, %d, %zu) failed",
  71.              __func__, fd, 0, (size_t)(offset + length));
  72.             return (-1);
  73.         }

  75.         /* 将需要处理的报文压缩为一个chain */
  76.         chain = evbuffer_chain_new(sizeof(struct evbuffer_chain_fd));
  77.         if (chain == NULL) {
  78.             event_warn("%s: out of memory", __func__);
  79.             munmap(mapped, length);
  80.             return (-1);
  81.         }

  83.         chain->flags |= EVBUFFER_MMAP | EVBUFFER_IMMUTABLE;
  84.         chain->buffer = mapped;  //映射后的内存地址，发送报文时使用该地址
  85.         chain->buffer_len = length + offset;
  86.         chain->off = length + offset;

  88.         info = EVBUFFER_CHAIN_EXTRA(struct evbuffer_chain_fd, chain);
  89.         /* 需要处理的文件，实际上将需要拷贝的文件 */
  90.         info->fd = fd;

  92.         EVBUFFER_LOCK(outbuf);
  93.         if (outbuf->freeze_end) {
  94.             info->fd = -1;
  95.             evbuffer_chain_free(chain);
  96.             ok = 0;
  97.         } else {
  98.             outbuf->n_add_for_cb += length;

  100.             evbuffer_chain_insert(outbuf, chain);

  102.             /* we need to subtract whatever we don't need */
  103.             evbuffer_drain(outbuf, offset);
  104.         }
  105.     } else /* 在以上几种技术都不支持的情况下，采用传统的先拷贝，然后再发送的方式 */
  106. #endif
  107.     { /* 普通的处理方式，先拷贝再发送 */
  108.         /* the default implementation */
  109.         struct evbuffer *tmp = evbuffer_new();
  110.         ev_ssize_t read;

  112.         if (tmp == NULL)
  113.             return (-1);

  115.         if (lseek(fd, offset, SEEK_SET) == -1) {
  116.             evbuffer_free(tmp);
  117.             return (-1);
  118.         }

  120.         /* we add everything to a temporary buffer, so that we
  121.          * can abort without side effects if the read fails.
  122.          */
  123.         while (length) { /* 实际是将数据拷贝到evbuffer中 */
  124.             read = evbuffer_readfile(tmp, fd, (ev_ssize_t)length);
  125.             if (read == -1) {
  126.                 evbuffer_free(tmp);
  127.                 return (-1);
  128.             }

  130.             length -= read;
  131.         }

  133.         EVBUFFER_LOCK(outbuf);
  134.         if (outbuf->freeze_end) {
  135.             evbuffer_free(tmp);
  136.             ok = 0;
  137.         } else {
  138.          /* 将读出来的buffer添加到输出的buffer中 */
  139.             evbuffer_add_buffer(outbuf, tmp);
  140.             evbuffer_free(tmp);

  142.             /* 关闭文件操作 */
  143.             close(fd);
  144.         }
  145.     }

  147.     if (ok)
  148.         evbuffer_invoke_callbacks(outbuf);
  149.     EVBUFFER_UNLOCK(outbuf);

  151.     return ok ? 0 : -1;
  152. }
从上面的代码中可知，在支持sendfile的系统中采用了sendfile的方式，在支持mmap的系统中采用mmap的方式，而都不支持则直接进行普通的处理，先拷贝再发送。

在上述不同的三种处理中，都是创建新的buffer_chain，新的内存块，然后插入到outbuf中，但是新的内存块中的零拷贝技术的内容不一样。普通情况下都是将对应的报文内容填充到一系列的buffer_chain。而在零拷贝中chain中保存的是evbuffer_chain_fd，该结构体中实际只是包含了文件的fd。但mmap中还保存了映射内存的起始地址和长度。而sendfile中则无数据相关的处理。
关于sendfile的具体发送操作如下所示:

点击(此处)折叠或打开

  1. /* 如果支持sendfile，一种零拷贝的技术 */
  2. #ifdef USE_SENDFILE
  3. static inline int
  4. evbuffer_write_sendfile(struct evbuffer *buffer, evutil_socket_t fd,
  5.     ev_ssize_t howmuch)
  6. {
  7.     struct evbuffer_chain *chain = buffer->first;
  8.     /* 采用fd的方式保存在chain的头部之后 */
  9.     struct evbuffer_chain_fd *info =
  10.      EVBUFFER_CHAIN_EXTRA(struct evbuffer_chain_fd, chain);

  12.     ev_ssize_t res;
  13.     off_t offset = chain->misalign;

  15.     ASSERT_EVBUFFER_LOCKED(buffer);
  16.     /* TODO(niels): implement splice */
  17.     /* 发送数据到fd,也就是将文件中的内容发送出去 */
  18.     res = sendfile(fd, info->fd, &offset, chain->off);
  19.     if (res == -1 && EVUTIL_ERR_RW_RETRIABLE(errno)) {
  20.         /* if this is EAGAIN or EINTR return 0; otherwise, -1 */
  21.         return (0);
  22.     }
  23.     return (res);
  24. }
上述的操作避免的文件到内存的拷贝，能够提高数据发送的效率。

而关于mmap的处理，加载内存之后还是需要按照常规的发送进行处理，只是减少了从文件到内存的拷贝过程。



阅读(1464) | 评论(0) | 转发(0) |
0

上一篇：linux笔记 - 内核配置与编译

下一篇：_IO, _IOR, _IOW, _IOWR 宏的用法与解析

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6