Linux下的I/O

Linux的I/O机制经历了一下几个阶段的演进：
(1)同步阻塞I/O: 用户进程进行I/O操作，一直阻塞到I/O操作完成为止。
(2)同步非阻塞I/O: 用户程序可以通过设置文件描述符的属性O_NONBLOCK，I/O操作可以立即返回，但是并不保证I/O操作成功。
(3)异步阻塞I/O: 用户进程可以对I/O事件进行阻塞，但是I/O操作并不阻塞。通过select/poll/epoll等函数调用来达到此目的。
(4)异步非阻塞I/O: 也叫做异步I/O(AIO)，用户程序可以通过向内核发出I/O请求命令，不用等带I/O事件真正发生，可以继续做另外的事情，等I/O操作完成，内核会通过函数回调或者信号机制通知用户进程。这样很大程度提高了系统吞吐量。

1、    一般典型的I/O(同步阻塞I/O)
它的典型流程如下：

示例代码：

while  ( (n = read(STDIN_FILENO, buf, BUFSIZ) )  >   0 )
   if  (write (STDOUT_FILENO, buf, n)  !=  n)
    err_sys (write error ”) ;

从应用程序的角度来说，read 调用可能会延续很长时间。实际上，在内核执行读操作和其他工作时，应用程序的确会被阻塞，也就是说应用程序不能做其它事情了。
2、   同步 非阻塞I/O
它的典型流程如下：

对于一个给定的描述符有两种方法对其指定非阻塞I / O：
(1) 如果是调用o p e n以获得该描述符，则可指定O _ N O N B L O C K标志。
(2) 对于已经打开的一个描述符，则可调用f c n t l打开O _ N O N B L O C K文件状态标志。
对于非阻塞I/O，read发现没有数据可读，则简单的返回-EAGAIN("try it agin")，而不是阻塞当前进程。来看一个非阻塞I/O的例子：

// nbtest.c
#include  < stdio.h >
#include  < unistd.h >
#include  < fcntl.h >
#include  < stdlib.h >
#include  < errno.h >

char  buffer[ 4096 ];

int  main( int  argc,  char   ** argv)
{
     int  delay  =   1 , n, m  =   0 ;

     if  (argc  >   1 )
        delay = atoi(argv[ 1 ]);
    fcntl( 0 , F_SETFL, fcntl( 0 ,F_GETFL)  |  O_NONBLOCK);  /*  stdin  */
    fcntl( 1 , F_SETFL, fcntl( 1 ,F_GETFL)  |  O_NONBLOCK);  /*  stdout  */

     while  ( 1 ) {
        n  =  read( 0 , buffer,  4096 );
         if  (n  >=   0 )
            m  =  write( 1 , buffer, n);
         if  ((n  <   0   ||  m  <   0 )  &&  (errno  !=  EAGAIN))
             break ;
        sleep(delay);
    }
    perror(n  <   0   ?   " stdin "  :  " stdout " );
    exit( 1 );
}

我们用strace来跟踪一下程序执行的结果：

out.txt的内容如下：

可以清楚的看到read读取失败的情况。实际上，该方式需要应用程序以一种轮询的方式来实现数据读取，多次无谓的系统调用会加大系统开销，影响应整个系统的吞吐量。

3、，异步阻塞I/O
即UNIX环境下的I/O多路转接(I/O multiplexing)，典型流程如下：

Linux中，poll、epoll和select这三个函数可以用来实现 I/O多路转接。它们的本质上是相同的：每个允许一个进程来决定它是否可读或者写一个或多个文件而不阻塞. 这些调用也可阻塞进程直到任何一个给定集合的文件描述符可用来读或写. 因此, 它们常常用在必须使用多输入输出流的应用程序。
3.1、poll函数

#include  < stropts.h >
#include  < poll.h >
int  poll( struct  pollfd  fdarray[],unsigned  long   nfds, int timeout) ;
返回：准备就绪的描述符数，若超时则为  0 ，若出错则为 -   1

struct  pollfd {
int fd ;  /*  file descriptor to check, or < 0 to ignore  */
short events;  /*  events of interest on fd  */
short revents;  /*  events that occurred on fd  */
} ;
fdarray数组中的元素数由nfds说明。

应将events成员设置为如下所示值的一个或几个。通过这些值告诉内核我们对该描述符关心的是什么。返回时，内核设置revents成员，以说明对该描述符发生了什么事件。 （注意，poll没有更改events成员）。events和revents的取值：

头四行测试可读性，接着三行测试可写性，最后三行则是异常条件。最后三行是
由内核在返回时设置的。即使在 events字段中没有指定这三个值，如果相应条件发生，则在revents中也返回它们。当一个描述符被挂断后（POLLUP） ，就不能再写向该描述符。但是仍可能从该描述符读取到数据。
poll的最后一个参数说明我们想要等待多少时间。有三种不同的情形：
•  timeout  == -1永远等待。常数INFTIM定义在<stropts.h>,其值通常是－1。当所指定
的描述符中的一个已准备好，或捕捉到一个信号则返回。如果捕捉到一个信号，则p o l l返回－1，errno设置为EINTR。
•  timeout == 0   不等待。测试所有描述符并立即返回。这是得到很多个描述符的状态而不阻塞p o l l函数的轮询方法。
• timeout > 0   等待timeout毫秒。当指定的描述符之一已准备好，或指定的时间值已超过时立即返回。如果已超时但是还没有一个描述符准备好，则返回值是 0。 （如果系统不提供毫秒分辨率，则timeout值取整到最近的支持值）。

3.2、例子

#include  < stdio.h >
#include  < unistd.h >
#include  < stdlib.h >
#include  < errno.h >
#include  < sys / poll.h >
#include  < fcntl.h >

char  buffer[ 4096 ];

int  main( int  argc,  char   ** argv)
{
     struct  pollfd pfd;
     int  n;

    fcntl( 0 , F_SETFL, fcntl( 0 ,F_GETFL)  |  O_NONBLOCK);  /*  stdin  */
    pfd.fd  =   0 ;   /*  stdin  */
    pfd.events  =  POLLIN;

     while  ( 1 ) {
        n = read( 0 , buffer,  4096 );
         if  (n  >=   0 )
            write( 1 , buffer, n);
    n  =  poll( & pfd,  1 ,  - 1 );
     if  (n  <   0 )
         break ;
    }
    perror( n < 0   ?   " stdin "  :  " stdout " );
    exit( 1 );
}

我们用strace来跟踪一下程序执行的结果：

out.txt文件：

该方式中，select(或poll)的调用仍然会阻塞进程，与一般典型的I/O不一样的它是等待事件通知。但是它引入了超时机制，可以让应用程序有权力避免过长时间等待；另一方面，如果应用程序需要读写多个文件，该方式可以一显身手。典型的应用就是telnet命令(详细见《UNIX环境高级编程》)。
3、    异步I/O
Linux 异步 I/O (AIO)，即异步非阻塞I/O，是 Linux 内核中提供的一个相当新的增强。它是 2.6 版本内核的一个标准特性，但是我们在 2.4 版本内核的补丁中也可以找到它。AIO 背后的基本思想是允许进程发起很多 I/O 操作，而不用阻塞或等待任何操作完成。稍后或在接收到 I/O 操作完成的通知时，进程就可以检索 I/O 操作的结果。
它的流程如下：

异步I/O 模型是一种处理与 I/O 重叠进行的模型。读请求会立即返回，说明 read 请求已经成功发起了。在后台完成读操作时，应用程序然后会执行其他处理操作。当 read 的响应到达时，就会产生一个信号或执行一个基于线程的回调函数来完成这次 I/O 处理过程。

在一个进程中为了执行多个 I/O 请求而对计算操作和 I/O 处理进行重叠处理的能力利用了处理速度与 I/O 速度之间的差异。当一个或多个 I/O 请求挂起时，CPU 可以执行其他任务；或者更为常见的是，在发起其他 I/O 的同时对已经完成的 I/O 进行操作。该方式的详细介绍见参考文献。

主要参考：
《UNIX环境高级编程》
http://www.ibm.com/developerworks/cn/linux/l-async/