Chinaunix首页 | 论坛 | 博客
  • 博客访问: 251961
  • 博文数量: 45
  • 博客积分: 802
  • 博客等级: 军士长
  • 技术积分: 470
  • 用 户 组: 普通用户
  • 注册时间: 2010-10-08 12:21
文章分类
文章存档

2014年(4)

2013年(4)

2012年(37)

我的朋友

分类: C/C++

2012-01-07 12:16:27

epoll的接口非常简单,一共就三个函数:


1. int epoll_create(int size);
创建一个epoll的句柄,size用来告诉内核这个监听的数目一共有多大。这个参数不同于select()中的第一个参数,给出最大监听的fd+1的值。需要注意的是,当创建好epoll句柄后,它就是会占用一个fd值,在linux下如果查看/proc/进程id/fd/,是能够看到这个fd的,所以在使用完epoll后,必须调用close()关闭,否则可能导致fd被耗尽。

 

2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
epoll
的事件注册函数,它不同与select()是在监听事件时告诉内核要监听什么类型的事件,而是在这里先注册要监听的事件类型。第一个参数是epoll_create()的返回值,第二个参数表示动作,用三个宏来表示:
EPOLL_CTL_ADD
:注册新的fdepfd中;
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队列里

 

3. int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
等待事件的产生,类似于select()调用。参数events用来从内核得到事件的集合,maxevents告之内核这个events有多大,这个 maxevents的值不能大于创建epoll_create()时的size,参数timeout是超时时间(毫秒,0会立即返回,-1将不确定,也有说法说是永久阻塞)。该函数返回需要处理的事件数目,如返回0表示已超时。


那么究竟如何来使用epoll呢?其实非常简单。
通过在包含一个头文件#include 以及几个简单的API将可以大大的提高你的网络服务器的支持人数。

首先通过create_epoll(int maxfds)来创建一个epoll的句柄,其中maxfds为你epoll所支持的最大句柄数。这个函数会返回一个新的epoll句柄,之后的所有操作将通过这个句柄来进行操作。在用完之后,记得用close()来关闭这个创建出来的epoll句柄。

之后在你的网络主循环里面,每一帧的调用epoll_wait(int epfd, epoll_event events, int max events, int timeout)来查询所有的网络接口,看哪一个可以读,哪一个可以写了。基本的语法为:
nfds = epoll_wait(kdpfd, events, maxevents, -1);
其中kdpfd为用epoll_create创建之后的句柄,events是一个epoll_event*的指针,当epoll_wait这个函数操作成功之后,epoll_events里面将储存所有的读写事件。max_events是当前需要监听的所有socket句柄数。最后一个timeout epoll_wait的超时,为0的时候表示马上返回,为-1的时候表示一直等下去,直到有事件范围,为任意正整数的时候表示等这么长的时间,如果一直没有事件,则范围。一般如果网络主循环是单独的线程的话,可以用-1来等,这样可以保证一些效率,如果是和主逻辑在同一个线程的话,则可以用0来保证主循环的效率。

下面是网上给出的示例:

 

  1. 1.    void setnonblocking(int sock){
  2. 2.    int opts;
  3. 3.    opts = fcntl(sock,F_GETFL);
  4. 4.    if(opts < 0){
  5. 5.    perror("fcntl(sock,GETFL)");
  6. 6.    exit(1);
  7. 7.    }
  8. 8.    opts = opts | O_NONBLOCK;
  9. 9.    if(fcntl(sock, F_SETFL, opts) < 0){
  10. 10.    perror("fcntl(sock, SETFL, opts)");
  11. 11.    exit(1);
  12. 12.    }
  13. 13.    }
  14. 14.    
  15. 15.    int main(int argc, char* argv[]){
  16. 16.    int i, maxi, listenfd, connfd, sockfd, epfd, nfds, portnumber;
  17. 17.    ssize_t n;
  18. 18.    char line[MAXLINE];
  19. 19.    socklen_t clilen;
  20. 20.    
  21. 21.    if(argc == 2){
  22. 22.    if((portnumber = atoi(argv[1])) < 0){
  23. 23.    fprintf(stderr, "Usage:%s portnumber/a/n", argv[0]);
  24. 24.    return 1;
  25. 25.    }
  26. 26.    }
  27. 27.    else{
  28. 28.    fprintf(stderr, "Usage:%s portnumber/a/n", argv[0]);
  29. 29.    return 1;
  30. 30.    }
  31. 31.    struct sockaddr_in serveraddr, clientaddr;
  32. 32.    memset(&serveraddr, 0, sizeof(serveraddr));
  33. 33.    memset(&clientaddr, 0, sizeof(clientaddr));
  34. 34.    serveraddr.sin_family = AF_INET;
  35. 35.    serveraddr.sin_addr.s_addr = inet_addr("127.0.0.1");
  36. 36.    serveraddr.sin_port = htons(portnumber);
  37. 37.    
  38. 38.    listenfd = socket(AF_INET, SOCK_STREAM, 0);
  39. 39.    bind(listenfd, (sockaddr *)&serveraddr, sizeof(serveraddr));
  40. 40.    listen(listenfd, LISTENQ);
  41. 41.    
  42. 42.    //声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件
  43. 43.    struct epoll_event ev;
  44. 44.    struct epool_event events[20];
  45. 45.    
  46. 46.    //生成用于处理accept的epoll专用的文件描述符
  47. 47.    epfd = epoll_create(256);
  48. 48.    
  49. 49.    //把socket设置为非阻塞方式,影响accept()的返回时机
  50. 50.    setnonblocking(listenfd);
  51. 51.    
  52. 52.    //设置与要处理的事件相关的文件描述符
  53. 53.    ev.data.fd = listenfd;
  54. 54.    
  55. 55.    //设置要处理的事件类型:监听套接字变为可读
  56. 56.    ev.events = EPOLLIN | EPOLLET;
  57. 57.    
  58. 58.    //注册epoll事件
  59. 59.    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);
  60. 60.    for ( ; ; ) {
  61. 61.    //等待epoll事件的发生
  62. 62.    nfds = epoll_wait(epfd, events, 20, 500);
  63. 63.    
  64. 64.    //处理所发生的所有事件
  65. 65.    for(i = 0; i < nfds; i++){
  66. 66.    //如果新监测到一个SOCKET用户连接到了绑定的SOCKET端口,建立新的连接。
  67. 67.    if(events[i].data.fd == listenfd)
  68. 68.    {
  69. 69.    int clilen = sizeof(clientaddr);
  70. 70.    connfd = accept(listenfd, (struct sockaddr *)&clientaddr, &clilen);
  71. 71.    if(connfd < 0){
  72. 72.    perror("accept()");
  73. 73.    exit(1);
  74. 74.    }
  75. 75.    setnonblocking(connfd);
  76. 76.    printf("accept a connection from %s.", inet_ntoa(clientaddr.sin_addr));
  77. 77.    //设置用于读操作的文件描述符,准备接受客户端请求
  78. 78.    ev.data.fd = connfd;
  79. 79.    
  80. 80.    //设置用于注测的读操作事件
  81. 81.    ev.events = EPOLLIN | EPOLLET;
  82. 82.    
  83. 83.    //注册ev
  84. 84.    epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
  85. 85.    }
  86. 86.    else if(events[i].events & EPOLLIN){//如果是已经连接的用户,并且收到数据,那么进行读入。
  87. 87.    if((sockfd = events[i].data.fd) < 0){
  88. 88.    continue;
  89. 89.    }
  90. 90.    if((n = read(sockfd, line, MAXLINE)) < 0){
  91. 91.    if (errno == ECONNRESET){
  92. 92.    close(sockfd);
  93. 93.    events[i].data.fd = -1;
  94. 94.    }
  95. 95.    else{
  96. 96.    printf("read() error\n");
  97. 97.    }
  98. 98.    }
  99. 99.    else if(n == 0){
  100. 100.    close(sockfd);
  101. 101.    events[i].data.fd = -1;
  102. 102.    }
  103. 103.    line[n] = '\0';
  104. 104.    printf("%s\n", line);
  105. 105.    //设置用于写操作的文件描述符
  106. 106.    ev.data.fd = sockfd;
  107. 107.    
  108. 108.    //设置用于注册的写操作事件
  109. 109.    ev.events = EPOLLOUT | EPOLLET;
  110. 110.    
  111. 111.    //修改sockfd上要处理的事件为EPOLLOUT
  112. 112.    epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev);
  113. 113.    }
  114. 114.    else if(events[i].events & EPOLLOUT){//如果被通知可写
  115. 115.    sockfd = events[i].data.fd;
  116. 116.    write(sockfd, line, n);
  117. 117.    
  118. 118.    //设置用于读操作的文件描述符
  119. 119.    ev.data.fd = sockfd;
  120. 120.    
  121. 121.    //设置用于注册的读操作事件
  122. 122.    ev.events = EPOLLIN | EPOLLET;
  123. 123.    
  124. 124.    //修改sockfd上要处理的事件为EPOLIN
  125. 125.    epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev);
  126. 126.    }
  127. 127.    }
  128. 128.    }
  129. 129.    return 0;
  130. 130.    }

 

理解后自己写了一个简单的回显服务器:

 

  1. 1.    #include <stdio.h>
  2. 2.    #include <stdio.h>
  3. 3.    #include <stdlib.h>
  4. 4.    #include <string.h>
  5. 5.    #include <sys/socket.h>
  6. 6.    #include <sys/types.h>
  7. 7.    #include <netinet/in.h>
  8. 8.    #include <netdb.h>
  9. 9.    #include <sys/epoll.h>
  10. 10.    #include <fcntl.h>
  11. 11.    
  12. 12.    typedef struct mydata{
  13. 13.    int fd;
  14. 14.    char *ptr;
  15. 15.    }mydata_t;
  16. 16.    
  17. 17.    int main(){
  18. 18.    int listenfd, connfd;
  19. 19.    struct sockaddr_in server;
  20. 20.    memset(&server, 0, sizeof(server));
  21. 21.    server.sin_family = AF_INET;
  22. 22.    server.sin_addr.s_addr = htonl(INADDR_ANY);
  23. 23.    server.sin_port = htons(5000);
  24. 24.    if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
  25. 25.    perror("socket()");
  26. 26.    exit(1);
  27. 27.    }
  28. 28.    int on = 1;
  29. 29.    if(setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0){
  30. 30.    perror("setsockopt()");
  31. 31.    exit(1);
  32. 32.    }
  33. 33.    if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) < 0){
  34. 34.    perror("bind()");
  35. 35.    exit(1);
  36. 36.    }
  37. 37.    if(listen(listenfd, 5) < 0){
  38. 38.    perror("listen()");
  39. 39.    exit(1);
  40. 40.    }
  41. 41.    int epfd = epoll_create(1024);
  42. 42.    struct epoll_event ev;
  43. 43.    struct epoll_event ev_r[20];
  44. 44.    int nfds, i, n;
  45. 45.    //一定注意,ev.data是union类型,而不是struct类型!
  46. 46.    //data就是8字节的用户数据,对于epoll_wait而言是透明的,即epoll只负责在内核和用户区之间传递这8字节的数据,不修改内容
  47. 47.    ev.data.fd = listenfd;
  48. 48.    ev.events = EPOLLIN;
  49. 49.    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);
  50. 50.    
  51. 51.    while(1){
  52. 52.    nfds = epoll_wait(epfd, ev_r, 20, -1);
  53. 53.    for(i = 0; i < nfds; i++){
  54. 54.    int fd = ev_r[i].data.fd;
  55. 55.    //有新连接待处理
  56. 56.    if(fd == listenfd){
  57. 57.    if((connfd = accept(listenfd, NULL, NULL)) < 0){
  58. 58.    perror("accept()");
  59. 59.    exit(1);
  60. 60.    }
  61. 61.    //为新连接的描述符分配缓冲区
  62. 62.    mydata_t md;
  63. 63.    md.fd = connfd;
  64. 64.    md.ptr = (char *)malloc(1025);
  65. 65.    //构造用户数据内容
  66. 66.    memcpy(&ev.data, &md, sizeof(md));
  67. 67.    ev.events = EPOLLIN;
  68. 68.    epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
  69. 69.    continue;
  70. 70.    }
  71. 71.    //普通连接
  72. 72.    //提取用户数据
  73. 73.    mydata_t m;
  74. 74.    memcpy(&m, &ev_r[i].data, sizeof(m));
  75. 75.    // char *buf = *((char **)((char *)&ev_r[i].data + 4));
  76. 76.    if(ev_r[i].events & EPOLLIN){
  77. 77.    n = read(fd, m.ptr, 1024);
  78. 78.    if(n < 0){
  79. 79.    perror("read()");
  80. 80.    free(m.ptr);
  81. 81.    close(fd);
  82. 82.    epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
  83. 83.    continue;
  84. 84.    }
  85. 85.    if(n == 0){
  86. 86.    close(fd);
  87. 87.    free(m.ptr);
  88. 88.    epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
  89. 89.    }
  90. 90.    else{
  91. 91.    m.ptr[n] = '\0';
  92. 92.    printf("%s\n", m.ptr);
  93. 93.    memcpy(&ev.data, &m, sizeof(m));
  94. 94.    ev.events = EPOLLOUT;
  95. 95.    epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev);
  96. 96.    }
  97. 97.    }
  98. 98.    else if(ev_r[i].events & EPOLLOUT){
  99. 99.    write(fd, m.ptr, strlen(m.ptr));
  100. 100.    memcpy(&ev.data, &m, sizeof(m));
  101. 101.    ev.events = EPOLLIN;
  102. 102.    epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev);
  103. 103.    }
  104. 104.    }
  105. 105.    }
  106. 106.    close(epfd);
  107. 107.    close(connfd);
  108. 108.    close(listenfd);
  109. 109.    return 0;
  110. 110.    }

 

 

阅读(4051) | 评论(2) | 转发(4) |
给主人留下些什么吧!~~

kkmm01052012-02-05 17:07:05

zhangjiakouzf: lt和et的性能分析在哪里啊.....
我的博文里面有,找找吧

zhangjiakouzf2012-01-29 10:46:27

lt和et的性能分析在哪里啊