概述
epoll 實際上是 poll 的一種改進,它可以處理大批量的句柄。而 poll 又是select 的一種改進。在select 中對所打開的文件描述符個數有一定的限制,該限制由 FD_SETSIZE 設置(一般爲 1024 或 2048), 而且內核中的 select 的實現是採用輪詢來處理描文件描述符集,因此效率低。當文件描述符集中的某個描述符處於可讀、可寫或異常狀態時,select 採用內存拷貝方法通知用戶空間。因此, 在select 模型中文件描述符個數受限且效率低的問題就很明顯。爲了解決select 對文件描述符個數的限制,採用了 poll 模型,但是 poll 依然不能解決 select 的效率問題。所以,最終epoll 模型重新對poll 模型進行改進 。
epoll 的優點如下所示:
- 處理大批量文件句柄:一個進程可以處理大批量的文件句柄,可處理文件描述符的個數遠大於 2048;
- 高效率:內核實現中 epoll 是根據每個描述符上面的回調函數實現的,並且只有處於活動狀態的套接字纔會主動調用該回調函數,其他不活動的套接字並不會去調用,因此,epoll 不必掃描整個文件描述符集,只需要掃描處於活動狀態的文件描述符。所有大大減低了效率。
- 加快內核與用戶的消息傳遞:epoll 是通過內核與用戶空間mmap 同一塊內存實現內核與用戶之間消息的傳遞。
- 內核微調:可以根據運行時所需內存動態調整內存大小。
epoll 系統調用
調用函數 epoll_create 創建 epoll 文件描述符,該函數原型如下:
/* epoll 系統調用函數 */
#include <sys/epoll.h>
/*
* 函數功能:創建epoll文件描述符;
* 返回值:若成功則返回新創建的文件描述符;
* 函數原型:
*/
int epoll_create(int size);
/*
* 參數size是epoll的最大文件描述符個數;
* 在新的系統內核中size已經不被使用;
*/
當創建好 epoll 文件描述符之後,接下來對需要監聽的相關套接字描述符進行操作,由epoll 操作函數epoll_ctl 實現,其原型如下:
/*
* 函數功能:操作某個epoll文件描述符;
* 返回值:若成功則返回0,否則出錯返回-1;
* 函數原型:
*/
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
/*
* 參數:
* epfd:由epoll_create創建的epoll文件描述符;
* fd:是關聯的文件描述符;
* op:是操作方式,有以下三種操作方式:
* EPOLL_CTL_ADD 將fd註冊到epfd中;
* EPOLL_CTL_MOD 修改已在epfd中註冊的fd事件;
* EPOLL_CTL_DEL 將fd從epfd中刪除;
*
* event:指向struct epoll_event 結構,表示需要監聽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 表示對應的文件描述符可讀;
* EPOLLOUT 表示對應的文件描述符可寫;
* EPOLLPRI 表示對應的文件描述符有緊急數據可讀;
* EPOLLERR 表示對應的文件描述符發生錯誤;
* EPOLLHUP 表示對應的文件描述符被掛載;
* EPOLLET 表示將EPOLL設置爲邊緣觸發模式(Edge Triggered);
* EPOLLONESHOT 表示只監聽一次事件,當監聽此次事件完成,若想繼續監聽,則需再次把該套接字描述符加入到EPOLL隊列中;
*/
例如:
struct epoll_event ev;
/* 設置與要處理的事件相關的文件描述符 */
ev.data.fd=listenfd;
/* 設置要處理的事件類型 */
ev.events=EPOLLIN|EPOLLET;
/* 註冊epoll事件 */
epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);
經過上面的操作之後,等待某些事情的發生由函數 epoll_wait 實現,其原型如下:
/*
* 函數功能:收集在epoll監聽事件中已發生的事件;
* 返回值:若成功則返回所發生的事件數,否則出錯返回-1;
* 函數原型:
*/
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
/*
* 參數:
* epfd:由epoll_create創建的epoll文件描述符;
* events:指向epoll_event結構體,用於保存已發生的事件;
* maxevents:每次能處理的最大事件數;
* timeout:等待IO 事件發生的超時時間:-1相當於阻塞,即不會立即返回;0相當於非阻塞,即立即返回;
*/
epoll 工作模式
epoll 有兩種工作模式:
- LT(level triggered):水平觸發是缺省的工作方式,並且同時支持block 和no-block socket。內核告訴你一個文件描述符是否就緒了,可以對這個就緒的fd 進行IO操作。若不進行任何操作,內核還是會繼續通知。
- ET(edge-triggered):邊緣觸發是高速工作方式,僅當狀態發生變化時才獲得通知。用戶收到一次通知後能夠完整地處理事件,內核不再通知這一事件。
具體實例可參考文章:How to use epoll? A complete example in C
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <errno.h>
#define MAXEVENTS 64
static int
make_socket_non_blocking (int sfd)
{
int flags, s;
flags = fcntl (sfd, F_GETFL, 0);
if (flags == -1)
{
perror ("fcntl");
return -1;
}
flags |= O_NONBLOCK;
s = fcntl (sfd, F_SETFL, flags);
if (s == -1)
{
perror ("fcntl");
return -1;
}
return 0;
}
static int
create_and_bind (char *port)
{
struct addrinfo hints;
struct addrinfo *result, *rp;
int s, sfd;
memset (&hints, 0, sizeof (struct addrinfo));
hints.ai_family = AF_UNSPEC; /* Return IPv4 and IPv6 choices */
hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */
hints.ai_flags = AI_PASSIVE; /* All interfaces */
s = getaddrinfo (NULL, port, &hints, &result);
if (s != 0)
{
fprintf (stderr, "getaddrinfo: %s\n", gai_strerror (s));
return -1;
}
for (rp = result; rp != NULL; rp = rp->ai_next)
{
sfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol);
if (sfd == -1)
continue;
s = bind (sfd, rp->ai_addr, rp->ai_addrlen);
if (s == 0)
{
/* We managed to bind successfully! */
break;
}
close (sfd);
}
if (rp == NULL)
{
fprintf (stderr, "Could not bind\n");
return -1;
}
freeaddrinfo (result);
return sfd;
}
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;
}
參考資料:
《epoll詳解》