I/O多路复用模型之select(二) 本文地址:http://www.itpux.com/thre

Select函数实现原理分析(转载)

select需要驱动程序的支持,驱动程序实现fops内的poll函数。select通过每个设备文件对应的poll函数提供的信息判断当前是否有资源可用(如可读或写),如果有的话则返回可用资源的文件描述符个数,没有的话则睡眠,等待有资源变为可用时再被唤醒继续执行。

下面我们分两个过程来分析select:

1. select的睡眠过程

支持阻塞操作的设备驱动通常会实现一组自身的等待队列如读/写等待队列用于支持上层(用户层)所需的BLOCK或NONBLOCK操作。当应用程序通过设备驱动访问该设备时(默认为BLOCK操作),若该设备当前没有数据可读或写,则将该用户进程插入到该设备驱动对应的读/写等待队列让其睡眠一段时间,等到有数据可读/写时再将该进程唤醒。

select就是巧妙的利用等待队列机制让用户进程适当在没有资源可读/写时睡眠,有资源可读/写时唤醒。下面我们看看select睡眠的详细过程。

select会循环遍历它所监测的fd_set(一组文件描述符(fd)的集合)内的所有文件描述符对应的驱动程序的poll函数。驱动程序提供的poll函数首先会将调用select的用户进程插入到该设备驱动对应资源的等待队列(如读/写等待队列),然后返回一个bitmask告诉select当前资源哪些可用。当select循环遍历完所有fd_set内指定的文件描述符对应的poll函数后,如果没有一个资源可用(即没有一个文件可供操作),则select让该进程睡眠,一直等到有资源可用为止,进程被唤醒(或者timeout)继续往下执行。

下面分析一下代码是如何实现的。
select的调用path如下:sys_select -> core_sys_select -> do_select
其中最重要的函数是do_select, 最主要的工作是在这里, 前面两个函数主要做一些准备工作。do_select定义如下:
int do_select(int n, fd_set_bits *fds, s64 *timeout)
{
       struct poll_wqueues table;
       poll_table *wait;
       int retval, i;

rcu_read_lock();
       retval = max_select_fd(n, fds);
       rcu_read_unlock();

if (retval 
              return retval;
       n = retval;

poll_initwait(&table);
       wait = &table.pt;
       if (!*timeout)
              wait = NULL;
       retval = 0;      //retval用于保存已经准备好的描述符数,初始为0
       for (;;) {
              unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;
              long __timeout;

set_current_state(TASK_INTERRUPTIBLE);      //将当前进程状态改为TASK_INTERRUPTIBLE

inp = fds->in; outp = fds->out; exp = fds->ex;
              rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;

for (i = 0; i 遍历每个描述符
                     unsigned long in, out, ex, all_bits, bit = 1, mask, j;
                     unsigned long res_in = 0, res_out = 0, res_ex = 0;
                     const struct file_operations *f_op = NULL;
                     struct file *file = NULL;

in = *inp++; out = *outp++; ex = *exp++;
                     all_bits = in | out | ex;
                     if (all_bits == 0) {
                            i += __NFDBITS;  // //如果这个字没有待查找的描述符, 跳过这个长字(32位)
                            continue;
                     }

for (j = 0; j 遍历每个长字里的每个位
                            int fput_needed;
                            if (i >= n)
                                   break;
                            if (!(bit & all_bits))
                                   continue;
                            file = fget_light(i, &fput_needed);
                            if (file) {
                                   f_op = file->f_op;
                                   MARK(fs_select, "%d %lld",
                                                 i, (long long)*timeout);
                                   mask = DEFAULT_POLLMASK;
                                   if (f_op && f_op->poll)
/* 在这里循环调用所监测的fd_set内的所有文件描述符对应的驱动程序的poll函数 */
                                          mask = (*f_op->poll)(file, retval ? NULL : wait);
                                   fput_light(file, fput_needed);
                                   if ((mask & POLLIN_SET) && (in & bit)) {
                                          res_in |= bit; //如果是这个描述符可读, 将这个位置位
                                          retval++; //返回描述符个数加1
                                   }
                                   if ((mask & POLLOUT_SET) && (out & bit)) {
                                          res_out |= bit;
                                          retval++;
                                   }
                                   if ((mask & POLLEX_SET) && (ex & bit)) {
                                          res_ex |= bit;
                                          retval++;
                                   }
                            }
                            cond_resched();
                     }
//返回结果
                     if (res_in)
                            *rinp = res_in;
                     if (res_out)
                            *routp = res_out;
                     if (res_ex)
                            *rexp = res_ex;
              }
              wait = NULL;
/* 到这里遍历结束。retval保存了检测到的可操作的文件描述符的个数。如果有文件可操作,则跳出for(;;)循环,直接返回。若没有文件可操作且timeout时间未到同时没有收到signal,则执行schedule_timeout睡眠。睡眠时间长短由__timeout决定,一直等到该进程被唤醒。 
那该进程是如何被唤醒的?被谁唤醒的呢?
我们看下面的select唤醒过程*/
              if (retval || !*timeout || signal_pending(current))
                     break;
              if(table.error) {
                     retval = table.error;
                     break;
              }

if (*timeout 
                     /* Wait indefinitely */
                     __timeout = MAX_SCHEDULE_TIMEOUT;
              } else if (unlikely(*timeout >= (s64)MAX_SCHEDULE_TIMEOUT - 1)) {
                     /* Wait for longer than MAX_SCHEDULE_TIMEOUT. Do it in a loop */
                     __timeout = MAX_SCHEDULE_TIMEOUT - 1;
                     *timeout -= __timeout;
              } else {
                     __timeout = *timeout;
                     *timeout = 0;
              }
              __timeout = schedule_timeout(__timeout);
              if (*timeout >= 0)
                     *timeout += __timeout;
       }
       __set_current_state(TASK_RUNNING);

poll_freewait(&table);

return retval;
}

2.  select的唤醒过程
前面介绍了select会循环遍历它所监测的fd_set内的所有文件描述符对应的驱动程序的poll函数。驱动程序提供的poll函数首先会将调用select的用户进程插入到该设备驱动对应资源的等待队列(如读/写等待队列),然后返回一个bitmask告诉select当前资源哪些可用。
一个典型的驱动程序poll函数实现如下:
(摘自《Linux Device Drivers – ThirdEdition》Page 165)
static unsigned int scull_p_poll(struct file *filp, poll_table *wait)
{
    struct scull_pipe *dev = filp->private_data;
    unsigned int mask = 0;
    /*
     * The buffer is circular; it is considered full
     * if "wp" is right behind "rp" and empty if the
     * two are equal.
     */
    down(&dev->sem);
    poll_wait(filp, &dev->inq,  wait);
    poll_wait(filp, &dev->outq, wait);
    if (dev->rp != dev->wp)
        mask |= POLLIN | POLLRDNORM;    /* readable */
    if (spacefree(dev))
        mask |= POLLOUT | POLLWRNORM;   /* writable */
    up(&dev->sem);
    return mask;
}
将用户进程插入驱动的等待队列是通过poll_wait做的。
Poll_wait定义如下:
static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
{
       if (p && wait_address)
              p->qproc(filp, wait_address, p);
}
这里的p->qproc在do_select内poll_initwait(&table)被初始化为__pollwait,如下:
void poll_initwait(struct poll_wqueues *pwq)
{
       init_poll_funcptr(&pwq->pt, __pollwait);
       pwq->error = 0;
       pwq->table = NULL;
       pwq->inline_index = 0;
}
__pollwait定义如下:
/* Add a new entry */
static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
                            poll_table *p)
{
       struct poll_table_entry *entry = poll_get_entry(p);
       if (!entry)
              return;
       get_file(filp);
       entry->filp = filp;
       entry->wait_address = wait_address;
       init_waitqueue_entry(&entry->wait, current);
       add_wait_queue(wait_address,&entry->wait);
}
通过init_waitqueue_entry初始化一个等待队列项,这个等待队列项关联的进程即当前调用select的进程。然后将这个等待队列项插入等待队列wait_address。Wait_address即在驱动poll函数内调用poll_wait(filp, &dev->inq,  wait);时传入的该驱动的&dev->inq或者&dev->outq等待队列。

注: 关于等待队列的工作原理可以参考下面这篇文档:
http://blog.chinaunix.net/u2/60011/showart_1334657.html

到这里我们明白了select如何将当前进程插入所有所监测的fd_set关联的驱动内的等待队列,那进程究竟是何时让出CPU进入睡眠状态的呢?
进入睡眠状态是在do_select内调用schedule_timeout(__timeout)实现的。当select遍历完fd_set内的所有设备文件,发现没有文件可操作时(即retval=0),则调用schedule_timeout(__timeout)进入睡眠状态。

唤醒该进程的过程通常是在所监测文件的设备驱动内实现的,驱动程序维护了针对自身资源读写的等待队列。当设备驱动发现自身资源变为可读写并且有进程睡眠在该资源的等待队列上时,就会唤醒这个资源等待队列上的进程。
举个例子,比如内核的8250 uart driver:
Uart是使用的Tty层维护的两个等待队列, 分别对应于读和写: (uart是tty设备的一种)
struct tty_struct {
       ……
       wait_queue_head_t write_wait;
       wait_queue_head_t read_wait;
       ……
}
当uart设备接收到数据,会调用tty_flip_buffer_push(tty);将收到的数据push到tty层的buffer。
然后查看是否有进程睡眠的读等待队列上,如果有则唤醒该等待会列。
过程如下:
serial8250_interrupt -> serial8250_handle_port -> receive_chars -> tty_flip_buffer_push ->
flush_to_ldisc -> disc->receive_buf 
在disc->receive_buf函数内:
if (waitqueue_active(&tty->read_wait))       //若有进程阻塞在read_wait上则唤醒
wake_up_interruptible(&tty->read_wait);

到这里明白了select进程被唤醒的过程。由于该进程是阻塞在所有监测的文件对应的设备等待队列上的,因此在timeout时间内,只要任意个设备变为可操作,都会立即唤醒该进程,从而继续往下执行。这就实现了select的当有一个文件描述符可操作时就立即唤醒执行的基本原理。

Referece:
1.       Linux Device Drivers – ThirdEdition
2.       内核等待队列机制原理分析
http://blog.chinaunix.net/u2/60011/showart_1334657.html
3.       Kernel code : Linux 2.6.18_pro500 - Montavista

本文来自ChinaUnix博客,如果查看原文请点:http://blog.chinaunix.net/u3/94284/showart_1917293.html

时间: 2024-10-28 08:00:09

I/O多路复用模型之select(二) 本文地址:http://www.itpux.com/thre的相关文章

linux下多路复用模型之Select模型

Linux关于并发网络分为Apache模型(Process per Connection (进程连接) ) 和TPC , 还有select模型,以及poll模型(一般是Epoll模型) Select模型极其作用:这文章讲述的很好,没必要重述已有的东西,就直接给链接 http://blog.csdn.net/turkeyzhou/article/details/8609360 我的理解: 1 /* According to POSIX.1-2001 */ 2 #include <sys/selec

I/O多路复用模型之select(一)

原理: select函数会等待,直到描述符句柄中有可用资源(可读.可写.异常)时返回,返回值是可用资源(可读/可写/异常等)描述符的个数(>0),0代表超时,-1代表错误.具体到内核大致是:当应用程序调用select() 函数, 内核就会相应调用 poll_wait(), 把当前进程添加到相应设备的等待队列上,然后将该应用程序进程设置为睡眠状态.直到该设备上的数据可以获取,然后调用wake_up()唤醒该应用程序进程.select每次轮训都会遍历所有描述符句柄. 函数接口: int select

几种典型的服务器网络编程模型归纳(select poll epoll)

1.同步阻塞迭代模型 同步阻塞迭代模型是最简单的一种IO模型. 其核心代码如下: bind(srvfd); listen(srvfd); for(;;) { clifd = accept(srvfd,...); //开始接受客户端来的连接 read(clifd,buf,...); //从客户端读取数据 dosomthingonbuf(buf); write(clifd,buf)//发送数据到客户端 } 上面的程序存在如下一些弊端: 1)如果没有客户端的连接请求,进程会阻塞在accept系统调用处

Linux的I/O多路复用机制之--select&poll

1. Linux下的五种I/O模型 1)阻塞I/O(blocking I/O)2)非阻塞I/O (nonblocking I/O)3) I/O复用(select 和poll) (I/O multiplexing)4)信号驱动I/O (signal driven I/O (SIGIO))5)异步I/O (asynchronous I/O (the POSIX aio_functions)) (前四种都是同步,只有最后一种才是异步IO.) 五种I/O模型的比较: 2.多路复用--select 系统提

[转]IO模型及select、poll、epoll和kqueue的区别

(一)首先,介绍几种常见的I/O模型及其区别,如下: blocking I/O nonblocking I/O I/O multiplexing (select and poll) signal driven I/O (SIGIO) asynchronous I/O (the POSIX aio_functions)—————异步IO模型最大的特点是 完成后发回通知. 阻塞与否,取决于实现IO交换的方式.      异步阻塞是基于select,select函数本身的实现方式是阻塞的,而采用sel

多路复用输入/输出 ---- select

一.select 系统提供select函数来实现多路复用输入/输出模型.select系统调用是用来让我们的程序监视多个文件句柄的状态变化的.程序会停在select这里阻塞等待,直到被监视的文件句柄有一个或多个发生了状态改变. 文件句柄,其实就是一个整数,我们最熟悉的句柄是0.1.2三个,0:标准输入,1:标准输出,2:标准错误输出.0.1.2是整数表示的,对应的FILE *结构:stdin.stdout.stderr. 二.select 相关 1.select函数  //一次可等待多个描述符 #

文本主题模型之LDA(二) LDA求解之Gibbs采样算法

本文是LDA主题模型的第二篇,读这一篇之前建议先读文本主题模型之LDA(一) LDA基础,同时由于使用了基于MCMC的Gibbs采样算法,如果你对MCMC和Gibbs采样不熟悉,建议阅读之前写的MCMC系列MCMC(四)Gibbs采样. 1. Gibbs采样算法求解LDA的思路 首先,回顾LDA的模型图如下: 在Gibbs采样算法求解LDA的方法中,我们的α,ηα,η是已知的先验输入,我们的目标是得到各个zdn,wknzdn,wkn对应的整体z? ,w? z→,w→的概率分布,即文档主题的分布和

django模型系统(二)

django模型系统(二) 常用查询 每一个django模型类,都有一个默认的管理器,objects QuerySet表示数据库中对象的列表.他可以有0到国歌过滤器.过滤器通过给定参数,缩小查询范围(filter). QuerySet等同与select语句,过滤器等同于一个限制字句,比如where.limit 使用.query可查看对应的SQL语句 all()获取所有 name.objects.all()queryset 获取第一条 name.objects.first()返回的是对象 获取最后

39.IO多路复用(用select实现伪并发)

IO多路复用 1.用select实现多端口被多客户端访问的多路复用伪并发 IO多路复用服务端:既读又写 # IO多路复用实现伪并发 用多个IO,可以监听多个文件句柄(socket对象)(一般是可以读了或者可以写了), # 一旦文件句柄出现变化,就可以感应到 # 对于原生的socket 只能处理一个请求,只能监听一个端口 # 1.如何让server端监听两个端口 import socket sk1 = socket.socket() sk1.bind(('127.0.0.1', 8001,)) s