Linux Epoll介紹和程式執行個體http://blog.csdn.net/sparkliang/article/details/4770655

Linux Epoll介紹和程式執行個體

1. Epoll 是何方神聖？

Epoll 可是當前在 Linux 下開發大規模並髮網絡程式的熱門人選， Epoll 在 Linux2.6 核心中正式引入，和 select 相似，其實都 I/O 多工技術而已 ，並沒有什麼神秘的。

其實在 Linux 下設計並髮網絡程式，向來不缺少方法，比如典型的 Apache 模型（ Process Per Connection ，簡稱PPC ）， TPC （ Thread Per Connection ）模型，以及 select 模型和 poll 模型，那為何還要再引入 Epoll 這個東東呢？那還是有得說說的 …

2. 常用模型的缺點

如果不擺出來其他模型的缺點，怎麼能對比出 Epoll 的優點呢。

2.1 PPC/TPC 模型

這兩種模型思想類似，就是讓每一個到來的串連一邊自己做事去，別再來煩我 。只是 PPC 是為它開了一個進程，而 TPC 開了一個線程。可是別煩我是有代價的，它要時間和空間啊，串連多了之後，那麼多的進程 / 線程切換，這開銷就上來了；因此這類模型能接受的最大串連數都不會高，一般在幾百個左右。

2.2 select 模型

1. 最大並發數限制，因為一個進程所開啟的 FD （檔案描述符）是有限制的，由 FD_SETSIZE 設定，預設值是1024/2048 ，因此 Select 模型的最大並發數就被相應限制了。自己改改這個 FD_SETSIZE ？想法雖好，可是先看看下面吧 …

2. 效率問題， select 每次調用都會線性掃描全部的 FD 集合，這樣效率就會呈現線性下降，把 FD_SETSIZE 改大的後果就是，大家都慢慢來，什嗎？都逾時了？？！！

3. 核心 / 使用者空間 記憶體拷貝問題，如何讓核心把 FD 訊息通知給使用者空間呢？在這個問題上 select 採取了記憶體拷貝方法。

2.3 poll 模型

基本上效率和 select 是相同的， select 缺點的 2 和 3 它都沒有改掉。

3. Epoll 的提升

把其他模型逐個批判了一下，再來看看 Epoll 的改進之處吧，其實把 select 的缺點反過來那就是 Epoll 的優點了。

3.1. Epoll 沒有最大並發串連的限制，上限是最大可以開啟檔案的數目，這個數字一般遠大於 2048, 一般來說這個數目和系統記憶體關係很大 ，具體數目可以 cat /proc/sys/fs/file-max 察看。

3.2. 效率提升， Epoll 最大的優點就在於它只管你“活躍”的串連 ，而跟串連總數無關，因此在實際的網路環境中， Epoll 的效率就會遠遠高於 select 和 poll 。

3.3. 記憶體拷貝， Epoll 在這點上使用了“共用記憶體 ”，這個記憶體拷貝也省略了。

 

 

4. Epoll 為什麼高效

Epoll 的高效和其資料結構的設計是密不可分的，這個下面就會提到。

首先回憶一下 select 模型，當有 I/O 事件到來時， select 通知應用程式有事件到了快去處理，而應用程式必須輪詢所有的 FD 集合，測試每個 FD 是否有事件發生，並處理事件；代碼像下面這樣：

 

int res = select(maxfd+1, &readfds, NULL, NULL, 120);

if (res > 0)

{

    for (int i = 0; i < MAX_CONNECTION; i++)

    {

        if (FD_ISSET(allConnection[i], &readfds))

        {

            handleEvent(allConnection[i]);

        }

    }

}

// if(res == 0) handle timeout, res < 0 handle error

 

Epoll 不僅會告訴應用程式有I/0 事件到來，還會告訴應用程式相關的資訊，這些資訊是應用程式填充的，因此根據這些資訊應用程式就能直接定位到事件，而不必遍曆整個FD 集合。

int res = epoll_wait(epfd, events, 20, 120);

for (int i = 0; i < res;i++)

{

    handleEvent(events[n]);

}

5. Epoll 關鍵資料結構

前面提到 Epoll 速度快和其資料結構密不可分，其關鍵資料結構就是：

struct epoll_event {

    __uint32_t events;      // Epoll events

    epoll_data_t data;      // User data variable

};

typedef union epoll_data {

    void *ptr;

    int fd;

    __uint32_t u32;

    __uint64_t u64;

} epoll_data_t;

可見 epoll_data 是一個 union 結構體 , 藉助於它應用程式可以儲存很多類型的資訊 :fd 、指標等等。有了它，應用程式就可以直接定位目標了。

6. 使用 Epoll

既然 Epoll 相比 select 這麼好，那麼用起來如何呢？會不會很繁瑣啊 … 先看看下面的三個函數吧，就知道 Epoll 的易用了。

 

int epoll_create(int size);

產生一個 Epoll 專用的檔案描述符，其實是申請一個核心空間，用來存放你想關注的 socket fd 上是否發生以及發生了什麼事件。 size 就是你在這個 Epoll fd 上能關注的最大 socket fd 數，大小自定，只要記憶體足夠。

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

控制某個 Epoll 檔案描述符上的事件：註冊、修改、刪除。其中參數 epfd 是 epoll_create() 建立 Epoll 專用的檔案描述符。相對於 select 模型中的 FD_SET 和 FD_CLR 宏。

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

等待 I/O 事件的發生；參數說明：

epfd: 由 epoll_create() 產生的 Epoll 專用的檔案描述符；

epoll_event: 用於回傳代處理事件的數組；

maxevents: 每次能處理的事件數目；

timeout: 等待 I/O 事件發生的逾時值；

返回傳生事件數目。

相對於 select 模型中的 select 函數。

7. 例子程式

下面是一個簡單 Echo Server 的例子程式，麻雀雖小，五髒俱全，還包含了一個簡單的逾時檢查機制，簡潔起見沒有做錯誤處理。

 

[cpp] view plaincopy

1. //   
2. // a simple echo server using epoll in linux  
3. //   
4. // 2009-11-05  
5. // by sparkling  
6. //   
7. #include <sys/socket.h>  
8. #include <sys/epoll.h>  
9. #include <netinet/in.h>  
10. #include <arpa/inet.h>  
11. #include <fcntl.h>  
12. #include <unistd.h>  
13. #include <stdio.h>  
14. #include <errno.h>  
15. #include <iostream>  
16. using namespace std;  
17. #define MAX_EVENTS 500  
18. struct myevent_s  
19. {  
20.     int fd;  
21.     void (*call_back)(int fd, int events, void *arg);  
22.     int events;  
23.     void *arg;  
24.     int status; // 1: in epoll wait list, 0 not in  
25.     char buff[128]; // recv data buffer  
26.     int len;  
27.     long last_active; // last active time  
28. };  
29. // set event  
30. void EventSet(myevent_s *ev, int fd, void (*call_back)(int, int, void*), void *arg)  
31. {  
32.     ev->fd = fd;  
33.     ev->call_back = call_back;  
34.     ev->events = 0;  
35.     ev->arg = arg;  
36.     ev->status = 0;  
37.     ev->last_active = time(NULL);  
38. }  
39. // add/mod an event to epoll  
40. void EventAdd(int epollFd, int events, myevent_s *ev)  
41. {  
42.     struct epoll_event epv = {0, {0}};  
43.     int op;  
44.     epv.data.ptr = ev;  
45.     epv.events = ev->events = events;  
46.     if(ev->status == 1){  
47.         op = EPOLL_CTL_MOD;  
48.     }  
49.     else{  
50.         op = EPOLL_CTL_ADD;  
51.         ev->status = 1;  
52.     }  
53.     if(epoll_ctl(epollFd, op, ev->fd, &epv) < 0)  
54.         printf("Event Add failed[fd=%d]/n", ev->fd);  
55.     else  
56.         printf("Event Add OK[fd=%d]/n", ev->fd);  
57. }  
58. // delete an event from epoll  
59. void EventDel(int epollFd, myevent_s *ev)  
60. {  
61.     struct epoll_event epv = {0, {0}};  
62.     if(ev->status != 1) return;  
63.     epv.data.ptr = ev;  
64.     ev->status = 0;  
65.     epoll_ctl(epollFd, EPOLL_CTL_DEL, ev->fd, &epv);  
66. }  
67. int g_epollFd;  
68. myevent_s g_Events[MAX_EVENTS+1]; // g_Events[MAX_EVENTS] is used by listen fd  
69. void RecvData(int fd, int events, void *arg);  
70. void SendData(int fd, int events, void *arg);  
71. // accept new connections from clients  
72. void AcceptConn(int fd, int events, void *arg)  
73. {  
74.     struct sockaddr_in sin;  
75.     socklen_t len = sizeof(struct sockaddr_in);  
76.     int nfd, i;  
77.     // accept  
78.     if((nfd = accept(fd, (struct sockaddr*)&sin, &len)) == -1)  
79.     {  
80.         if(errno != EAGAIN && errno != EINTR)  
81.         {  
82.             printf("%s: bad accept", __func__);  
83.         }  
84.         return;  
85.     }  
86.     do  
87.     {  
88.         for(i = 0; i < MAX_EVENTS; i++)  
89.         {  
90.             if(g_Events[i].status == 0)  
91.             {  
92.                 break;  
93.             }  
94.         }  
95.         if(i == MAX_EVENTS)  
96.         {  
97.             printf("%s:max connection limit[%d].", __func__, MAX_EVENTS);  
98.             break;  
99.         }  
100.         // set nonblocking  
101.         if(fcntl(nfd, F_SETFL, O_NONBLOCK) < 0) break;  
102.         // add a read event for receive data  
103.         EventSet(&g_Events[i], nfd, RecvData, &g_Events[i]);  
104.         EventAdd(g_epollFd, EPOLLIN|EPOLLET, &g_Events[i]);  
105.         printf("new conn[%s:%d][time:%d]/n", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), g_Events[i].last_active);  
106.     }while(0);  
107. }  
108. // receive data  
109. void RecvData(int fd, int events, void *arg)  
110. {  
111.     struct myevent_s *ev = (struct myevent_s*)arg;  
112.     int len;  
113.     // receive data  
114.     len = recv(fd, ev->buff, sizeof(ev->buff)-1, 0);    
115.     EventDel(g_epollFd, ev);  
116.     if(len > 0)  
117.     {  
118.         ev->len = len;  
119.         ev->buff[len] = '/0';  
120.         printf("C[%d]:%s/n", fd, ev->buff);  
121.         // change to send event  
122.         EventSet(ev, fd, SendData, ev);  
123.         EventAdd(g_epollFd, EPOLLOUT|EPOLLET, ev);  
124.     }  
125.     else if(len == 0)  
126.     {  
127.         close(ev->fd);  
128.         printf("[fd=%d] closed gracefully./n", fd);  
129.     }  
130.     else  
131.     {  
132.         close(ev->fd);  
133.         printf("recv[fd=%d] error[%d]:%s/n", fd, errno, strerror(errno));  
134.     }  
135. }  
136. // send data  
137. void SendData(int fd, int events, void *arg)  
138. {  
139.     struct myevent_s *ev = (struct myevent_s*)arg;  
140.     int len;  
141.     // send data  
142.     len = send(fd, ev->buff, ev->len, 0);  
143.     ev->len = 0;  
144.     EventDel(g_epollFd, ev);  
145.     if(len > 0)  
146.     {  
147.         // change to receive event  
148.         EventSet(ev, fd, RecvData, ev);  
149.         EventAdd(g_epollFd, EPOLLIN|EPOLLET, ev);  
150.     }  
151.     else  
152.     {  
153.         close(ev->fd);  
154.         printf("recv[fd=%d] error[%d]/n", fd, errno);  
155.     }  
156. }  
157. void InitListenSocket(int epollFd, short port)  
158. {  
159.     int listenFd = socket(AF_INET, SOCK_STREAM, 0);  
160.     fcntl(listenFd, F_SETFL, O_NONBLOCK); // set non-blocking  
161.     printf("server listen fd=%d/n", listenFd);  
162.     EventSet(&g_Events[MAX_EVENTS], listenFd, AcceptConn, &g_Events[MAX_EVENTS]);  
163.     // add listen socket  
164.     EventAdd(epollFd, EPOLLIN|EPOLLET, &g_Events[MAX_EVENTS]);  
165.     // bind & listen  
166.     sockaddr_in sin;  
167.     bzero(&sin, sizeof(sin));  
168.     sin.sin_family = AF_INET;  
169.     sin.sin_addr.s_addr = INADDR_ANY;  
170.     sin.sin_port = htons(port);  
171.     bind(listenFd, (const sockaddr*)&sin, sizeof(sin));  
172.     listen(listenFd, 5);  
173. }  
174. int main(int argc, char **argv)  
175. {  
176.     short port = 12345; // default port  
177.     if(argc == 2){  
178.         port = atoi(argv[1]);  
179.     }  
180.     // create epoll  
181.     g_epollFd = epoll_create(MAX_EVENTS);  
182.     if(g_epollFd <= 0) printf("create epoll failed.%d/n", g_epollFd);  
183.     // create & bind listen socket, and add to epoll, set non-blocking  
184.     InitListenSocket(g_epollFd, port);  
185.     // event loop  
186.     struct epoll_event events[MAX_EVENTS];  
187.     printf("server running:port[%d]/n", port);  
188.     int checkPos = 0;  
189.     while(1){  
190.         // a simple timeout check here, every time 100, better to use a mini-heap, and add timer event  
191.         long now = time(NULL);  
192.         for(int i = 0; i < 100; i++, checkPos++) // doesn't check listen fd  
193.         {  
194.             if(checkPos == MAX_EVENTS) checkPos = 0; // recycle  
195.             if(g_Events[checkPos].status != 1) continue;  
196.             long duration = now - g_Events[checkPos].last_active;  
197.             if(duration >= 60) // 60s timeout  
198.             {  
199.                 close(g_Events[checkPos].fd);  
200.                 printf("[fd=%d] timeout[%d--%d]./n", g_Events[checkPos].fd, g_Events[checkPos].last_active, now);  
201.                 EventDel(g_epollFd, &g_Events[checkPos]);  
202.             }  
203.         }  
204.         // wait for events to happen  
205.         int fds = epoll_wait(g_epollFd, events, MAX_EVENTS, 1000);  
206.         if(fds < 0){  
207.             printf("epoll_wait error, exit/n");  
208.             break;  
209.         }  
210.         for(int i = 0; i < fds; i++){  
211.             myevent_s *ev = (struct myevent_s*)events[i].data.ptr;  
212.             if((events[i].events&EPOLLIN)&&(ev->events&EPOLLIN)) // read event  
213.             {  
214.                 ev->call_back(ev->fd, events[i].events, ev->arg);  
215.             }  
216.             if((events[i].events&EPOLLOUT)&&(ev->events&EPOLLOUT)) // write event  
217.             {  
218.                 ev->call_back(ev->fd, events[i].events, ev->arg);  
219.             }  
220.         }  
221.     }  
222.     // free resource  
223.     return 0;  
224. }