eventfd以及epoll原理分析

4:16:00 PM 0 Comments

这两天公司代码中用到了epoll。然后在跟同事闲扯的过程中发现了Linux中有eventfd。两者虽然名字看起来差不多，但是相关性倒是不多。
为了弄明白这两个东西到底在内核上是怎么实现的，这两天将内核这两个部分的相关代码看了下，也终于明白了这两个东西的实现机制。
后续几篇博客我尽量将这两个东西的工作原理阐述清楚，但是自己的语言表达能力比较差，也只能是尽量了。

今天这篇博客首先是介绍两者的使用方式，恰巧两者能够在一个程序中搞定，我就写了下面的小程序来展示两者的功能。
  1. #include <stdio.h>
  2. #include <unistd.h>
  3. #include <sys/time.h>
  4. #include <stdint.h>
  5. #include <pthread.h>
  6. #include <sys/eventfd.h>
  7. #include <sys/epoll.h>

  9. int efd = -1;

  11. void *read_thread(void *dummy)
  12. {
  13.     int ret = 0;
  14.     uint64_t count = 0;
  15.     int ep_fd = -1;
  16.     struct epoll_event events[10];

  18.     if (efd < 0)
  19.     {
  20.         printf("efd not inited.\n");
  21.         goto fail;
  22.     }

  24.     ep_fd = epoll_create(1024);
  25.     if (ep_fd < 0)
  26.     {
  27.         perror("epoll_create fail: ");
  28.         goto fail;
  29.     }

  31.     {
  32.         struct epoll_event read_event;

  34.         read_event.events = EPOLLHUP | EPOLLERR | EPOLLIN;
  35.         read_event.data.fd = efd;

  37.         ret = epoll_ctl(ep_fd, EPOLL_CTL_ADD, efd, &read_event);
  38.         if (ret < 0)
  39.         {
  40.             perror("epoll ctl failed:");
  41.             goto fail;
  42.         }
  43.     }

  45.     while (1)
  46.     {
  47.         ret = epoll_wait(ep_fd, &events[0], 10, 5000);
  48.         if (ret > 0)
  49.         {
  50.             int i = 0;
  51.             for (; i < ret; i++)
  52.             {
  53.                 if (events[i].events & EPOLLHUP)
  54.                 {
  55.                     printf("epoll eventfd has epoll hup.\n");
  56.                     goto fail;
  57.                 }
  58.                 else if (events[i].events & EPOLLERR)
  59.                 {
  60.                     printf("epoll eventfd has epoll error.\n");
  61.                     goto fail;
  62.                 }
  63.                 else if (events[i].events & EPOLLIN)
  64.                 {
  65.                     int event_fd = events[i].data.fd;
  66.                     ret = read(event_fd, &count, sizeof(count));
  67.                     if (ret < 0)
  68.                     {
  69.                         perror("read fail:");
  70.                         goto fail;
  71.                     }
  72.                     else
  73.                     {
  74.                         struct timeval tv;

  76.                         gettimeofday(&tv, NULL);
  77.                         printf("success read from efd, read %d bytes(%llu) at %lds %ldus\n",
  78.                                ret, count, tv.tv_sec, tv.tv_usec);
  79.                     }
  80.                 }
  81.             }
  82.         }
  83.         else if (ret == 0)
  84.         {
  85.             /* time out */
  86.             printf("epoll wait timed out.\n");
  87.             break;
  88.         }
  89.         else
  90.         {
  91.             perror("epoll wait error:");
  92.             goto fail;
  93.         }
  94.     }

  96. fail:
  97.     if (ep_fd >= 0)
  98.     {
  99.         close(ep_fd);
  100.         ep_fd = -1;
  101.     }

  103.     return NULL;
  104. }

  106. int main(int argc, char *argv[])
  107. {
  108.     pthread_t pid = 0;
  109.     uint64_t count = 0;
  110.     int ret = 0;
  111.     int i = 0;

  113.     efd = eventfd(0, 0);
  114.     if (efd < 0)
  115.     {
  116.         perror("eventfd failed.");
  117.         goto fail;
  118.     }

  120.     ret = pthread_create(&pid, NULL, read_thread, NULL);
  121.     if (ret < 0)
  122.     {
  123.         perror("pthread create:");
  124.         goto fail;
  125.     }

  127.     for (i = 0; i < 5; i++)
  128.     {
  129.         count = 4;
  130.         ret = write(efd, &count, sizeof(count));
  131.         if (ret < 0)
  132.         {
  133.             perror("write event fd fail:");
  134.             goto fail;
  135.         }
  136.         else
  137.         {
  138.             struct timeval tv;

  140.             gettimeofday(&tv, NULL);
  141.             printf("success write to efd, write %d bytes(%llu) at %lds %ldus\n",
  142.                    ret, count, tv.tv_sec, tv.tv_usec);
  143.         }

  145.         sleep(1);
  146.     }

  148. fail:
  149.     if (0 != pid)
  150.     {
  151.         pthread_join(pid, NULL);
  152.         pid = 0;
  153.     }

  155.     if (efd >= 0)
  156.     {
  157.         close(efd);
  158.         efd = -1;
  159.     }
  160.     return ret;
  161. }

  1. gcc main.c -Werror -Wall -lpthread
最后执行效果为
  1. success write to efd, write 8 bytes(4) at 1328805612s 21939us
  2. success read from efd, read 8 bytes(4) at 1328805612s 21997us
  3. success write to efd, write 8 bytes(4) at 1328805613s 22247us
  4. success read from efd, read 8 bytes(4) at 1328805613s 22287us
  5. success write to efd, write 8 bytes(4) at 1328805614s 22462us
  6. success read from efd, read 8 bytes(4) at 1328805614s 22503us
  7. success write to efd, write 8 bytes(4) at 1328805615s 22688us
  8. success read from efd, read 8 bytes(4) at 1328805615s 22726us
  9. success write to efd, write 8 bytes(4) at 1328805616s 22973us
  10. success read from efd, read 8 bytes(4) at 1328805616s 23007us
  11. epoll wait timed out.
eventfd具体与pipe有点像，用来完成两个线程之间事件触发，但是同事说现在已经支持到进程级别，现在我还没有验证过。能够用来作为线程之间简单通讯，类似于pthread_cond_t。
epoll则是linux提供的一种多路复用技术，完成与select，poll等一样的功能，完成对多个文件描述符进行等待。本文上述代码仅仅用到了一个文件描述符。
epoll比select的优势网络随处可见，这就不多说了。

应用程序就已经写到这了，对于内核里面具体是怎么搞的，将会在以后的博客中尽量解释清楚。

Some say he’s half man half fish, others say he’s more of a seventy/thirty split. Either way he’s a fishy bastard.