epoll

epoll簡介

epoll 是Linux內核中的一種可擴展IO事件處理機制，最早在 Linux 2.5.44內核中引入，可被用於代替POSIX select 和 poll 系統調用，並且在具有大量應用程序請求時能夠獲得較好的性能（ 此時被監視的文件描述符數目非常大，與舊的 select 和 poll 系統調用完成操作所需 O(n) 不同， epoll能在O(1)時間內完成操作，所以性能相當高），epoll 與 FreeBSD的kqueue類似，都向用戶空間提供了自己的文件描述符來進行操作。

 

int epoll_create(int size);

創建一個epoll的句柄，size用來告訴內核需要監聽的數目一共有多大。當創建好 epoll句柄後，它就是會佔用一個fd值，在linux下如果查看/proc/進程id/fd/，是能夠看到這個fd的，所以在使用完epoll後，必 須調用close() 關閉，否則可能導致fd被耗盡。

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

epoll的事件註冊函數，第一個參數是 epoll_create() 的返回值，第二個參數表示動作，使用如下三個宏來表示：

EPOLL_CTL_ADD    //註冊新的fd到epfd中；
EPOLL_CTL_MOD    //修改已經註冊的fd的監聽事件；
EPOLL_CTL_DEL    //從epfd中刪除一個fd；

第三個參數是需要監聽的fd，第四個參數是告訴內核需要監聽什麼事，struct epoll_event 結構如下：

typedef union epoll_data
{
  void        *ptr;
  int          fd;
  __uint32_t   u32;
  __uint64_t   u64;
} epoll_data_t;

struct epoll_event {
__uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

events 可以是以下幾個宏的集合：

 

EPOLLIN     //表示對應的文件描述符可以讀（包括對端SOCKET正常關閉）；
EPOLLOUT    //表示對應的文件描述符可以寫；
EPOLLPRI    //表示對應的文件描述符有緊急的數據可讀（這裏應該表示有帶外數據到來）；
EPOLLERR    //表示對應的文件描述符發生錯誤；
EPOLLHUP    //表示對應的文件描述符被掛斷；
EPOLLET     //將EPOLL設爲邊緣觸發(Edge Triggered)模式，這是相對於水平觸發(Level Triggered)來說的。
EPOLLONESHOT//只監聽一次事件，當監聽完這次事件之後，如果還需要繼續監聽這個socket的話，需要再次把這個socket加入到EPOLL隊列裏。

當對方關閉連接(FIN), EPOLLERR，都可以認爲是一種EPOLLIN事件，在read的時候分別有0，-1兩個返回值。

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

參數events用來從內核得到事件的集合，maxevents 告之內核這個events有多大，這個 maxevents 的值不能大於創建 epoll_create() 時的size，參數 timeout 是超時時間（毫秒，0會立即返回，-1將不確定，也有說法說是永久阻塞）。該函數返回需要處理的事件數目，如返回0表示已超時。

EPOLL事件有兩種模型 Level Triggered (LT) 和 Edge Triggered (ET)：

LT(level triggered，水平觸發模式)

(1)缺省的工作方式。

(2)同時支持 block 和 non-block socket。

(3)在這種做法中，內核告訴你一個文件描述符是否就緒了，然後你可以對這個就緒的fd進行IO操作。如果你不作任何操作，內核還是會繼續通知你 的，所以，這種模式編程出錯誤可能性要小一點。

ET(edge-triggered，邊緣觸發模式)

(1)高速工作方式。

(2)只支持no-block socket。

(3)在這種模式下，當描述符從未就緒變爲就緒時，內核通過epoll告訴你。然後它會假設你知道文件描述符已經就緒，並且不會再爲那個文件描述 符發送更多的就緒通知，等到下次有新的數據進來的時候纔會再次出發就緒事件。

 

 

epoll 例子

事件循環：

#define MAXEVENTS 64

int
main (int argc, char *argv[])
{
  int sfd, s;
  int efd;
  struct epoll_event event;
  struct epoll_event *events;

  if (argc != 2)
    {
      fprintf (stderr, "Usage: %s [port]\n", argv[0]);
      exit (EXIT_FAILURE);
    }

  sfd = create_and_bind (argv[1]);
  if (sfd == -1)
    abort ();

  s = make_socket_non_blocking (sfd);
  if (s == -1)
    abort ();

  s = listen (sfd, SOMAXCONN);
  if (s == -1)
    {
      perror ("listen");
      abort ();
    }

  efd = epoll_create1 (0);
  if (efd == -1)
    {
      perror ("epoll_create");
      abort ();
    }

  event.data.fd = sfd;
  event.events = EPOLLIN | EPOLLET;
  s = epoll_ctl (efd, EPOLL_CTL_ADD, sfd, &event);
  if (s == -1)
    {
      perror ("epoll_ctl");
      abort ();
    }

  /* Buffer where events are returned */
  events = calloc (MAXEVENTS, sizeof event);

  /* The event loop */
  while (1)
    {
      int n, i;

      n = epoll_wait (efd, events, MAXEVENTS, -1);
      for (i = 0; i < n; i++)
    {
      if ((events[i].events & EPOLLERR) ||
              (events[i].events & EPOLLHUP) ||
              (!(events[i].events & EPOLLIN)))
        {
              /* An error has occured on this fd, or the socket is not
                 ready for reading (why were we notified then?) */
          fprintf (stderr, "epoll error\n");
          close (events[i].data.fd);
          continue;
        }

      else if (sfd == events[i].data.fd)
        {
              /* We have a notification on the listening socket, which
                 means one or more incoming connections. */
              while (1)
                {
                  struct sockaddr in_addr;
                  socklen_t in_len;
                  int infd;
                  char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];

                  in_len = sizeof in_addr;
                  infd = accept (sfd, &in_addr, &in_len);
                  if (infd == -1)
                    {
                      if ((errno == EAGAIN) ||
                          (errno == EWOULDBLOCK))
                        {
                          /* We have processed all incoming
                             connections. */
                          break;
                        }
                      else
                        {
                          perror ("accept");
                          break;
                        }
                    }

                  s = getnameinfo (&in_addr, in_len,
                                   hbuf, sizeof hbuf,
                                   sbuf, sizeof sbuf,
                                   NI_NUMERICHOST | NI_NUMERICSERV);
                  if (s == 0)
                    {
                      printf("Accepted connection on descriptor %d "
                             "(host=%s, port=%s)\n", infd, hbuf, sbuf);
                    }

                  /* Make the incoming socket non-blocking and add it to the
                     list of fds to monitor. */
                  s = make_socket_non_blocking (infd);
                  if (s == -1)
                    abort ();

                  event.data.fd = infd;
                  event.events = EPOLLIN | EPOLLET;
                  s = epoll_ctl (efd, EPOLL_CTL_ADD, infd, &event);
                  if (s == -1)
                    {
                      perror ("epoll_ctl");
                      abort ();
                    }
                }
              continue;
            }
          else
            {
              /* We have data on the fd waiting to be read. Read and
                 display it. We must read whatever data is available
                 completely, as we are running in edge-triggered mode
                 and won't get a notification again for the same
                 data. */
              int done = 0;

              while (1)
                {
                  ssize_t count;
                  char buf[512];

                  count = read (events[i].data.fd, buf, sizeof buf);
                  if (count == -1)
                    {
                      /* If errno == EAGAIN, that means we have read all
                         data. So go back to the main loop. */
                      if (errno != EAGAIN)
                        {
                          perror ("read");
                          done = 1;
                        }
                      break;
                    }
                  else if (count == 0)
                    {
                      /* End of file. The remote has closed the
                         connection. */
                      done = 1;
                      break;
                    }

                  /* Write the buffer to standard output */
                  s = write (1, buf, count);
                  if (s == -1)
                    {
                      perror ("write");
                      abort ();
                    }
                }

              if (done)
                {
                  printf ("Closed connection on descriptor %d\n",
                          events[i].data.fd);

                  /* Closing the descriptor will make epoll remove it
                     from the set of descriptors which are monitored. */
                  close (events[i].data.fd);
                }
            }
        }
    }

  free (events);

  close (sfd);

  return EXIT_SUCCESS;
}

main() 首先調用 create_and_bind() 建立套接字，然後將其設置爲非阻塞的，再調用 listen(2)。之後創建一個epoll 實例 efd（文件描述符），並將其加入到sfd的監聽套接字中以邊沿觸發方式等待事件輸入。

外層的 while 循環是主事件循環，它調用了 epoll_wait(2)，此時線程仍然被阻塞等待事件，當事件可用時，epoll_wait(2) 將會在events參數中返回可用事件。

epoll 實例 efd 在每次事件到來並需要添加新的監聽時就會得到更新，並刪除死亡的鏈接。

當事件可用時(epoll_wait()返回時)，可能有一下三種類型：

• Errors: 當錯誤情況出現時，或者不是與讀取數據相關的事件通告，我們只是關閉相關的描述符，關閉該描述符會自動的將其從被epoll 實例 efd 監聽的的集合中刪除。
• New connections: 當監聽的文件描述符 sfd 可讀時，此時會有一個或多個新的連接到來，當新連接到來時，accept(2) 該連接，並打印一條信息，將其設置爲非阻塞的並把它加入到被 epoll 實例監聽的集合中。
• Client data: 當數據在客戶端描述符可用時，我們使用 read(2) 在一個內部循環中每次讀取512 字節數據。由於我們必須讀取所有的可用數據，此時我們並不能獲取更多的事件，因爲描述符是以邊沿觸發監聽的，讀取的數據被寫到 stdout (fd=1) (write(2))。如果 read(2) 返回 0，意味着到了文件末尾EOF，我們可以關閉客戶端連接，如果返回  -1， errno 會被設置成 EAGAIN, 這意味着所有的數據已經被讀取，可以返回主循環了。