[置顶] select poll epoll使用示例

    select，poll，epoll都是IO多路复用的机制。I/O多路复用就通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。
    这三个方法都要调用驱动中的struct file_operations中的.poll方法。poll是一个函数指针，申明如下
unsigned int (*poll) (struct file *, struct poll_table_struct *);
在驱动中poll的实现方法如下：
.....
static unsigned int Test_poll(struct file *filp, poll_table *wait)
{
unsigned int mask = 0;
......... 
poll_wait(filp, &(int_queue), wait);
if(read ready)
{ 
mask |=POLLIN | POLLRDNORM;
}
        if(write ready)
{ 
mask |=return POLLOUT | POLLWRNORM;
}
............
        return  mask ;
}
static const struct file_operations Test_fops = {
.owner = THIS_MODULE,
.......
.poll = Test_poll ,
        .......
};
注意：.poll本身是不会阻塞的，不论读写条件是否满足，都会立即返回。阻塞是在调用 .poll的时候实现的，poll返回0的时候，将阻塞，等待int_queue。
int_queue是一个 类型为wait_queue_head_t结构的等待队列。
在驱动初始化的时候调用init_waitqueue_head(&(int_queue));初始化等待队列
当读写条件满足的时候，调用wake_up_interruptible(&( int_queue));唤醒等待队列


poll方法返回的数据如下：
常量             说明
POLLIN           普通或优先级数据可读
POLLRDNORM       普通数据可读
POLLRDBAND       优先级数据可读
POLLPRI          高优先级数据可读
POLLOUT          普通数据可写
POLLWRNORM       普通数据可写
POLLWRBAND       优先级数据可写
POLLERR          发生错误
POLLHUP          发生挂起
POLLNVAL         描述字不是一个打开的文件


1 select的实现示例
  select相关函数原型如下：
  
  int select(int maxfd,fd_set *rdset,fd_set *wrset,fd_set *exset,struct timeval *timeout);
  maxfd是需要监视的最大的文件描述符值+1，例如如果我们分别要监视3个文件描述符fd1 fd2 fd3 ,数值分别为100,500,1000，那么maxfd就必须写1001。
  rdset,wrset,exset分别对应于需要检测的可读文件描述符的集合，可写文件描述符的集 合及异常文件描述符的集合。
  timeout 为设置的超时时间，如果为NULL，则一直等待，直到监视的资源可用。
  函数返回值：小于0 函数执行出错 ，超时将返回0 。大于0 表示有资源可用的数目，例如我们分别监视了fd1 fd2 fd3 那么如果fd1 发的同时可以写了则返回2。


  对fd_set的操作可以通过下面的宏来操作：
  FD_ZERO(fd_set*); 用来清空fd_set集合，即让fd_set集合不再包含任何文件句柄。
  FD_SET(int ,fd_set *); 用来将一个给定的文件描述符加入fd_set集合之中
  FD_CLR(int ,fd_set*); 用来将一个给定的文件描述符从集合中删除
  FD_ISSET(int ,fd_set*);检测fd在fdset集合中是否存在，存在返回真，否则，返回假（也可以认为集合中指定的文件描述符是否可以读写）。


  这里需要注意的是select执行的时候，rdset、wrset、exset、timeout、会被改变，所以每次执行select前一定要重新设置下。例如rdset分别监视fd1 fd2 fd3，当fd3可以读都，select返回，那么这个时候rdset就只设置了fd3，如果我们没有重新设置，那fd1 fd2就监视不到了。同样timeout也是一样，当超时返回后，timeout变为0，如果这个时候没有重新设置,那么select函数就会立即返回了，无论是否资源可用。


  下面是示例代码：
void * Test_select( void*  arg )
{
fd_set fdsi;
fd_set fdso;
int maxfdp ;
int ret;
struct timeval timeout;
        int fd ,fd2;
fd = open(DEV_FILENAME, O_RDWR  );
if(fd<0) 
{
printf("open device error\r\n");

return NULL ;
}
fd2 = open(DEV_FILENAME2, O_RDWR  );
if(fd<0) 
{
printf("open device error\r\n");

return NULL ;
}

    maxfdp = fd>fd2?fd+1:fd2+1 ;
    
    while(exitFlag==0)
    {
    timeout.tv_sec=1;//1秒超时
        timeout.tv_usec = 0;
        FD_ZERO(&fdsi); 
    FD_SET(fd,&fdsi);
    FD_SET(fd2,&fdsi);
         
    
    FD_ZERO(&fdso); 
    FD_SET(fd,&fdso);
    FD_SET(fd2,&fdso); 
   
    ret = select(maxfdp,&fdsi,&fdso,NULL,&timeout);
  //如果不需要超时可以改为  ret = select(maxfdp,&fdsi,&fdso,NULL,NULL);
    if(ret==0)
    {
    printf("select timeout\r\n");
    continue;
    }
    else if(ret<0)
    {
    printf("select error\r\n");
    exitFlag= 1;
    }
    else
    {
     
    if(FD_ISSET(fd,&fdsi)) 
    {
       //read data;
    }
    else if(FD_ISSET(fd,&fdso)) 
    {
       //write data;
    }
   
    if(FD_ISSET(fd2,&fdsi)) 
    {
       //read data;
    }
    else if(FD_ISSET(fd2,&fdso)) 
    {
       //write data;
    }
    }
    }
close(fd );
close(fd2 );
return NULL;
}
说明：在系统内核中select是采用轮询来处理的，如果需要监视的文件描述符越多，就需要消耗更多的资源。所以如果要监视很多文件描述符，最好使用epoll(epoll在后面会介绍)。
select监视的最大数量有限制，通常是1024。


2 poll的实现示例


  poll实现比select简单，只有一个函数就可以了，函数原型如下
  int poll (struct pollfd *fds, nfds_t nfds, int timeout);
  参数fds ：pollfd 结构体的指针，这个结构描述了需要监视的文件描述符和我们关心的事件。这个函数也可以监视多个文件描述符。
            struct pollfd结构描述如下
  struct pollfd
  {
    int fd;                     /* poll 的文件描述符.  */
    short int events;           /* fd 上感兴趣的事件(需要等待的事件).  */
    short int revents;          /* fd 上实际发生的事件. 也就是poll返回时 的状态*/
  }; 
  参数 nfds：fds的个数，也就是要监视的文件描述符的个数。
  参数 timeout ： 超时的毫秒数，如果为-1则表示永远等待。
  函数返回值 返回0表示超时 返回值小于0函数出错，大于0 实际可用的资源数




  下面是示例代码：  
void * Test_poll( void*  arg )
{
    struct pollfd Events[2] ;
    int ret;
    int fd ,fd2;
    fd = open(DEV_FILENAME, O_RDWR  );
    if(fd<0) 
    {
        printf("open device error\r\n");
return NULL ;
    }
    fd2 = open(DEV_FILENAME2, O_RDWR  );
    if(fd<0) 
    {
printf("open device error\r\n");
return NULL ;
    }
    Events[0].fd = fd;
    Events[0].events = POLLIN | POLLERR;     /*关心读取和出错事件*/
 
    Events[1].fd = fd2;
    Events[1].events = POLLIN | POLLERR;     /*关心读取和出错事件*/
    while(exitFlag==0)
    {
     
    ret = poll ((struct pollfd *)&Events[0], 2, -1);//如果要设置超时可以把-1改为要设置的超时的毫秒数
    if(ret==0)
    {
    printf("poll timeout\r\n");
    continue;
    }
    else if(ret<0)
    {
    printf("poll error\r\n");
    exitFlag= 1;
    }
    else
    {
     
    if (Events[0].revents & POLLERR) 
    {
printf ("device error!\n");              
                }
if (Events[1].revents & POLLERR) 
    {
printf ("device error!\n");              
                }
                         
            if (Events[0].revents & POLLIN) {
                  //read data;              
            } 
            
            if (Events[1].revents & POLLIN) {
                  //read data;              
            } 
    }
    }
    close(fd );
    close(fd2 );
    return NULL;
}
说明：poll函数的实现方法和select类似，所以等待的文件描述符越多，越消耗资源。


3 epoll实现说明
  epoll实现很简单，就三个函数就解决了，下面是函数申明：


  int epoll_create(int size);
  这个函数的功能创建一个epoll的句柄，当创建好epoll句柄后，它就是会占用一个fd值所以使用完epoll后一定要close掉，避免占用资源。
  参数size：用来告诉内核这个监听的数目一共有多少。 自从Linux 2.6.8开始，size参数被忽略，但是依然要大于0。
  返回值：成功返回epoll的句柄，失败返回-1。


  int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)；
  参数 epfd： epoll的句柄，是epoll_create()的返回值
  参数 op：操作码。用三个宏来表示的
           EPOLL_CTL_ADD：注册新的fd到epfd中；
           EPOLL_CTL_MOD：修改已经注册的fd的监听事件；
           EPOLL_CTL_DEL：从epfd中删除一个fd；
  参数 fd：要监视的文件描述符。
  参数event ：要监视的事件的描述。
  struct epoll_event的结构说明如下：
  struct epoll_event {
__uint32_t events; /* 需要监视的事件，如EPOLLIN、EPOLLOUT等等 */
epoll_data_t data; /* 用户数据*/
  }; 
  typedef union epoll_data
  {
  void        *ptr;
  int          fd;
  __uint32_t   u32;
  __uint64_t   u64;
  } epoll_data_t;
  返回值：0成功，小于0 失败


  int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
  该函数等待事件产生。
  参数epfd： epoll的句柄
  参数events：从内核得到的事件集合
  参数maxevents：events的大小。events的大小取决于可能同时产生的事件的数量。例如我们虽然同时监视了fd1 fd2 fd3 三个文件描述符，但是这3个之间是不可能同时可读或者可写的，那么将maxevents设置为1也没有问题，但是如果三个事件可能会同时产生，那么最好就设置为3。如果设置为1,3个事件同时产生，epoll_wait第一次返回的时候就会只返回第一事件了。（不过在此调用这个函数的时候，会马上返回。例如当fd1 fd2 fd3同时可读，但是maxevents为1时，那么第一次调用epoll_wait返回值为1，报告fd1的时间，第二次调用，马上返回1，调用fd2的事件，第三次调用马上返回1，报告fd3的事件.而如果maxevents为3的话，当fd1 fd2 fd3同时可读，epoll_wait返回值为3，同时报告fd1 fd2 fd3的事件）。
  参数timeout：超时的毫秒数，如果为-1表示一直等待直到事件产生。


  返回值：超时返回0 ，返回小于0 函数执行失败，大于0，返回值为实际的事件数目。


下面是示例代码：


static int epoll_register( int  epoll_fd, int  fd )
{
    struct epoll_event  ev;
    int                 ret, flags;
    /*****************************************/ 
    flags = fcntl(fd, F_GETFL);
    fcntl(fd, F_SETFL, flags | O_NONBLOCK);
    //资料上说需要设置为非阻塞的方式，我试了下，似乎不设置为非阻塞的方式也不会出错
    /**********************************************/
    ev.events  = EPOLLIN;
    ev.data.fd = fd; 
    ret = epoll_ctl( epoll_fd, EPOLL_CTL_ADD, fd, &ev );  
    return ret;
}
void * Test_epoll( void*  arg )
{
int   epoll_fd  ,ret ;
int count =0;
struct epoll_event   events[2];
int                  ne, nevents; 
int fd ,fd2;
fd = open(DEV_FILENAME, O_RDWR  );
if(fd<0) 
{
printf("open device error\r\n");

return NULL ;
}
fd2 = open(DEV_FILENAME2, O_RDWR  );
if(fd<0) 
{
printf("open device error\r\n");

return NULL ;
} 
 
epoll_fd = epoll_create(1);
epoll_register( epoll_fd, fd );
epoll_register( epoll_fd, fd2 );
while(exitFlag==0)
{

        nevents = epoll_wait( epoll_fd, events, 2, -1 );
        if (nevents < 0) 
        {
            exitFlag =1；
                printf("epoll_wait() unexpected error: %s", strerror(errno));
            }
           
       
        
        for (ne = 0; ne < nevents; ne++) 
        {
            if ((events[ne].events & (EPOLLERR|EPOLLHUP)) != 0) 
            {
                 
            }
            if ((events[ne].events & EPOLLIN) != 0) 
            {
            if( fd == events[ne].data.fd)
            {
            //read data;
            }
            else if( fd2 == events[ne].data.fd)
            {
            //read data;
            }
             
 
           
            }
        }
}
epoll_ctl( epoll_fd, EPOLL_CTL_DEL, fd, NULL ); 
epoll_ctl( epoll_fd, EPOLL_CTL_DEL, fd2, NULL ); 
ret=close(epoll_fd);
 
return NULL;
}


最后总结：


（1）select，poll实现需要自己不断轮询所有fd集合，直到设备就绪，期间可能要睡眠和唤醒多次交替。而epoll其实也需要调用epoll_wait不断轮询就绪链表，期间也可能多次睡眠和唤醒交替，但是它是设备就绪时，调用回调函数，把就绪fd放入就绪链表中，并唤醒在epoll_wait中进入睡眠的进程。虽然都要睡眠和交替，但是select和poll在“醒着”的时候要遍历整个fd集合，而epoll在“醒着”的时候只要判断一下就绪链表是否为空就行了，这节省了大量的CPU时间。这就是回调机制带来的性能提升。


（2）select，poll每次调用都要把fd集合从用户态往内核态拷贝一次，并且要把current往设备等待队列中挂一次，而epoll只要一次拷贝，而且把current往等待队列上挂也只挂一次（在epoll_wait的开始，注意这里的等待队列并不是设备等待队列，只是一个epoll内部定义的等待队列）。这也能节省不少的开销。
所以最好尽量使用epoll。他的速度更快，系统开销更小。