buffered i/o and unbuffered i/o

unbuffered I/O. buffered I/O<转载>

 

1. buffered I/O, 即标准I/O
首先,要明确,unbuffered I/O只是相对于buffered I/O,即标准I/O来说的.
而不是说unbuffered I/O读写磁盘时不用缓冲.实际上,内核是存在高速缓冲区来进行
真正的磁盘读写的,不过这里要讨论的buffer跟内核中的缓冲区无关.
buffered I/O的目的是什么呢?
很简单,buffered I/O的目的就是为了提高效率.
请明确一个关系,那就是,
              
buffered I/O库函数(fread, fwrite等,用户空间) <----call--->   unbuffered I/O系统调用(read,write等,内核空间)<-------> 读写磁盘
buffered I/O库函数都是调用相关的unbuffered I/O系统调用来实现的,他们并不直接读写磁盘.
那么,效率的提高从何而来呢?
注意到,buffered I/O中都是库函数,而unbuffered I/O中为系统调用,使用库函数的效率是高于使用系统调用的.
buffered I/O就是通过尽可能的少使用系统调用来提高效率的.
它的基本方法是,在用户进程空间维护一块缓冲区,第一次读(库函数)的时候用read(系统调用)多从内核读出一些数据,
下次在要读(库函数)数据的时候,先从该缓冲区读,而不用进行再次read(系统调用)了.
同样,写的时候,先将数据写入(库函数)一个缓冲区,多次以后,在集中进行一次write(系统调用),写入内核空间.
buffered I/O中的fgets, puts, fread, fwrite等和unbufferedI/O中的read,write等就是调用和被调用的关系
下面是一个利用buffered I/O读取数据的例子:

[Copy to clipboard] [ - ]CODE:#include
#include
#include
#include
#include
int main(void)
{
   char buf[5];
   FILE *myfile = stdin;
   fgets(buf, 5, myfile);
   fputs(buf, myfile);
  
   return 0;
}
buffered I/O中的"buffer"到底是指什么呢?
这个buffer在什么地方呢?
FILE是什么呢?它的空间是怎么分配的呢?

要弄清楚这些问题,就要看看FILE是如何定义和运作的了.
(特别说明,在平时写程序时,不用也不要关心FILE是如何定义和运作的,最好不要直接操作
它,这里使用它,只是为了说明buffered IO)
下面的这个是glibc给出的FILE的定义,它是实现相关的,别的平台定义方式不同.
struct _IO_FILE {
int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
#define _IO_file_flags _flags
/* The following pointers correspond to the C++ streambuf protocol. */
/* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
char* _IO_read_ptr; /* Current read pointer */
char* _IO_read_end; /* End of get area. */
char* _IO_read_base; /* Start of putback+get area. */
char* _IO_write_base; /* Start of put area. */
char* _IO_write_ptr; /* Current put pointer. */
char* _IO_write_end; /* End of put area. */
char* _IO_buf_base; /* Start of reserve area. */
char* _IO_buf_end; /* End of reserve area. */
/* The following fields are used to support backing up and undo. */
char *_IO_save_base; /* Pointer to start of non-current get area. */
char *_IO_backup_base; /* Pointer to first valid character of backup area */
char *_IO_save_end; /* Pointer to end of non-current get area. */
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
};
上面的定义中有三组重要的字段:
1.
char* _IO_read_ptr; /* Current read pointer */
char* _IO_read_end; /* End of get area. */
char* _IO_read_base; /* Start of putback+get area. */
2.
char* _IO_write_base; /* Start of put area. */
char* _IO_write_ptr; /* Current put pointer. */
char* _IO_write_end; /* End of put area. */
3.
char* _IO_buf_base; /* Start of reserve area. */
char* _IO_buf_end; /* End of reserve area. */
其中,
_IO_read_base 指向"读缓冲区"
_IO_read_end   指向"读缓冲区"的末尾
_IO_read_end - _IO_read_base "读缓冲区"的长度

_IO_write_base 指向"写缓冲区"
_IO_write_end 指向"写缓冲区"的末尾
_IO_write_end - _IO_write_base "写缓冲区"的长度
_IO_buf_base   指向"缓冲区"
_IO_buf_end 指向"缓冲区"的末尾
_IO_buf_end - _IO_buf_base "缓冲区"的长度
上面的定义貌似给出了3个缓冲区,实际上上面的_IO_read_base,
_IO_write_base, _IO_buf_base都指向了同一个缓冲区.
这个缓冲区跟上面程序中的char buf[5];没有任何关系.
他们在第一次buffered IO操作时有编译器申请空间,最后由编译器释放.
(再次声明,这里只是glibc的实现,别的实现可能会不同,后面就不再强调了)

请看下面的程序(这里给的是stdin,行缓冲的例子):

[Copy to clipboard] [ - ]CODE:#include
#include
#include
#include
#include
int main(void)
{
   char buf[5];
   FILE *myfile =stdin;
   printf("before reading\n");
   printf("read buffer base %p\n", myfile->_IO_read_base);
   printf("read buffer length %d\n", myfile->_IO_read_end - myfile->_IO_read_base);
   printf("write buffer base %p\n", myfile->_IO_write_base);
   printf("write buffer length %d\n", myfile->_IO_write_end - myfile->_IO_write_base);
   printf("buf buffer base %p\n", myfile->_IO_buf_base);
   printf("buf buffer length %d\n", myfile->_IO_buf_end - myfile->_IO_buf_base);
   printf("\n");
   fgets(buf, 5, myfile);
   fputs(buf, myfile);
   printf("\n");
   printf("after reading\n");
   printf("read buffer base %p\n", myfile->_IO_read_base);
   printf("read buffer length %d\n", myfile->_IO_read_end - myfile->_IO_read_base);
   printf("write buffer base %p\n", myfile->_IO_write_base);
   printf("write buffer length %d\n", myfile->_IO_write_end - myfile->_IO_write_base);
   printf("buf buffer base %p\n", myfile->_IO_buf_base);
   printf("buf buffer length %d\n", myfile->_IO_buf_end - myfile->_IO_buf_base);
   return 0;
}
可以看到,在读操作之前,myfile的缓冲区是没有被分配的,在一次读之后,myfile的缓冲区才被分配.
这个缓冲区既不是内核中的缓冲区,也不是用户分配的缓冲区,而是有编译器维护的用户进程空间中的缓冲区.
(当然,用户可以可以维护该缓冲区,这里不做讨论了)

上面的例子只是说明了buffered I/O缓冲区的存在,下面从全缓冲,行缓冲和无缓冲3个方面看一下buffered I/O
是如何工作的.

1.1. 全缓冲
下面是APUE上的原话:
全缓冲"在填满标准I/O缓冲区后才进行实际的I/O操作.对于驻留在磁盘上的文件通常是由标准I/O库实施全缓冲的"
书中这里"实际的I/O操作"实际上容易引起误导,这里并不是读写磁盘,而应该是进行read或write的系统调用
下面两个例子会说明这个问题

[Copy to clipboard] [ - ]CODE:#include
#include
#include
#include
#include
int main(void)
{
   char buf[5];
   char *cur;
   FILE *myfile;
   myfile = fopen("bbb.txt", "r");
   printf("before reading, myfile->_IO_read_ptr: %d\n", myfile->_IO_read_ptr - myfile->_IO_read_base);
   fgets(buf, 5, myfile); //仅仅读4个字符
   cur = myfile->_IO_read_base;
   while (cur < myfile->_IO_read_end) //实际上读满了这个缓冲区
   {
printf("%c",*cur);
cur++;
   }
   printf("\nafter reading, myfile->_IO_read_ptr: %d\n", myfile->_IO_read_ptr - myfile->_IO_read_base);
   return 0;
}
上面提到的bbb.txt文件的内容是由很多行的"123456789"组成
上例中,fgets(buf, 5, myfile); 仅仅读4个字符,但是,缓冲区已被写满,
但是_IO_read_ptr却向前移动了5位,下次再次调用读操作时,
只要要读的位数不超过myfile->_IO_read_end - myfile->_IO_read_ptr
那么就不需要再次调用系统调用read,只要将数据从myfile的缓冲区拷贝到
buf即可(从myfile->_IO_read_ptr开始拷贝)

全缓冲读的时候,
_IO_read_base始终指向缓冲区的开始
_IO_read_end始终指向已从内核读入缓冲区的字符的下一个
(对全缓冲来说,buffered I/O读每次都试图都将缓冲区读满)
_IO_read_ptr始终指向缓冲区中已被用户读走的字符的下一个
(_IO_read_end < (_IO_buf_base-_IO_buf_end)) && (_IO_read_ptr == _IO_read_end)时则已经到达文件末尾
其中_IO_buf_base-_IO_buf_end是缓冲区的长度
一般大体的工作情景为:
第一次fgets(或其他的)时,标准I/O会调用read将缓冲区充满,下一次fgets不调用read而是直接从该缓冲区中拷贝数据,直到
缓冲区的中剩余的数据不够时,再次调用read.在这个过程中,_IO_read_ptr就是用来记录缓冲区中哪些数据是已读的,
哪些数据是未读的.

[Copy to clipboard] [ - ]CODE:#include
#include
#include
#include
#include
int main(void)
{
   char buf[2048]={0};
   int i;
   FILE *myfile;
  
   myfile = fopen("aaa.txt", "r+");
  
   i= 0;
   while (i<2048)
   {
fwrite(buf+i, 1, 512, myfile);
i +=512;
//注释掉这句则可以写入aaa.txt
myfile->_IO_write_ptr = myfile->_IO_write_base;
printf("%p write buffer base\n", myfile->_IO_write_base);
printf("%p buf buffer base \n", myfile->_IO_buf_base);
printf("%p read buffer base \n", myfile->_IO_read_base);
printf("%p write buffer ptr \n", myfile->_IO_write_ptr);
printf("\n");
   }
   return 0;
}
上面这个是关于全缓冲写的例子.
全缓冲时,只有当标准I/O自动flush(比如当缓冲区已满时)或者手工调用fflush时,
标准I/O才会调用一次write系统调用.
例子中,fwrite(buf+i, 1, 512, myfile);这一句只是将buf+i接下来的512个字节
写入缓冲区,由于缓冲区未满,标准I/O并未调用write.
此时,myfile->_IO_write_ptr = myfile->_IO_write_base;会导致标准I/O认为
没有数据写入缓冲区,所以永远不会调用write,这样aaa.txt文件得不到写入.
注释掉myfile->_IO_write_ptr = myfile->_IO_write_base;前后,看看效果

全缓冲写的时候:
_IO_write_base始终指向缓冲区的开始
_IO_write_end全缓冲的时候,始终指向缓冲区的最后一个字符的下一个
(对全缓冲来说,buffered I/O写总是试图在缓冲区写满之后,再系统调用write)
_IO_write_ptr始终指向缓冲区中已被用户写入的字符的下一个
flush的时候,将_IO_write_base和_IO_write_ptr之间的字符通过系统调用write写入内核

1.2. 行缓冲
下面是APUE上的原话:
行缓冲"当输入输出中遇到换行符时,标准I/O库执行I/O操作. "
书中这里"执行O操作"也容易引起误导,这里不是读写磁盘,而应该是进行read或write的系统调用

下面两个例子会说明这个问题
第一个例子可以用来说明下面这篇帖子的问题


[Copy to clipboard] [ - ]CODE:#include
#include
int main(void)
{
   char buf[5];
   char buf2[10];
  
   fgets(buf, 5, stdin); //第一次输入时,超过5个字符
   puts(stdin->_IO_read_ptr);//本句说明整行会被一次全部读入缓冲区,而非仅仅上面需要的个字符
  
   stdin->_IO_read_ptr = stdin->_IO_read_end; //标准I/O会认为缓冲区已空,再次调用read
                                          //注释掉,再看看效果
  
   printf("\n");
   puts(buf);
  
   fgets(buf2, 10, stdin);
   puts(buf2);
  
   return 0;
}
上例中, fgets(buf, 5, stdin); 仅仅需要4个字符,但是,输入行中的其他数据也被写入缓冲区,
但是_IO_read_ptr向前移动了5位,下次再次调用fgets操作时,就不需要再次调用系统调用read,
只要将数据从stdin的缓冲区拷贝到buf2即可(从stdin->_IO_read_ptr开始拷贝)
stdin->_IO_read_ptr = stdin->_IO_read_end;会导致标准I/O会认为缓冲区已空,
再次fgets则需要再次调用read.比较一下将该句注释掉前后的效果

行缓冲读的时候,
_IO_read_base始终指向缓冲区的开始
_IO_read_end始终指向已从内核读入缓冲区的字符的下一个
_IO_read_ptr始终指向缓冲区中已被用户读走的字符的下一个
(_IO_read_end < (_IO_buf_base-_IO_buf_end)) && (_IO_read_ptr == _IO_read_end)时则已经到达文件末尾
其中_IO_buf_base-_IO_buf_end是缓冲区的长度

[Copy to clipboard] [ - ]CODE:#include
#include
#include
#include
#include
char buf[5]={'1','2', '3', '4', '5'}; //最后一个不要是\n,是\n的话,标准I/O会自动flush的
                                                //这是行缓冲跟全缓冲的重要区别
void writeLog(FILE *ftmp)
{
   fprintf(ftmp, "%p write buffer base\n", stdout->_IO_write_base);
   fprintf(ftmp, "%p buf buffer base \n", stdout->_IO_buf_base);
   fprintf(ftmp, "%p read buffer base \n", stdout->_IO_read_base);
   fprintf(ftmp, "%p write buffer ptr \n", stdout->_IO_write_ptr);
   fprintf(ftmp, "\n");
}
int main(void)
{
   int i;
   FILE *ftmp;
   ftmp = fopen("ccc.txt", "w");
  
   i= 0;
   while (i<4)
   {
fwrite(buf, 1, 5, stdout);
i++;
*stdout->_IO_write_ptr++ = '\n';//可以单独把这句打开,看看效果
//getchar();//getchar()会标准I/O将缓冲区输出
//打开下面的注释,你就会发现屏幕上什么输出也没有
//stdout->_IO_write_ptr = stdout->_IO_write_base;
writeLog(ftmp); //这个只是为了查看缓冲区指针的变化

   }
   return 0;
}
这个例子将将FILE结构中指针的变化写入的文件ccc.txt
运行后可以有兴趣的话,可以看看.
上面这个是关于行缓冲写的例子.
stdout->_IO_write_ptr = stdout->_IO_write_base;会使得标准I/O认为
缓冲区是空的,从而没有任何输出.
可以将上面程序中的注释分别去掉,看看运行结果
行缓冲时,下面3个条件之一会导致缓冲区立即被flush
1. 缓冲区已满
2. 遇到一个换行符;比如将上面例子中buf[4]改为'\n'时
3. 再次要求从内核中得到数据时;比如上面的程序加上getchar()会导致马上输出


行缓冲写的时候:
_IO_write_base始终指向缓冲区的开始
_IO_write_end始终指向缓冲区的开始
_IO_write_ptr始终指向缓冲区中已被用户写入的字符的下一个
flush的时候,将_IO_write_base和_IO_write_ptr之间的字符通过系统调用write写入内核
1.3. 无缓冲
无缓冲时,标准I/O不对字符进行缓冲存储.典型代表是stderr
这里的无缓冲,并不是指缓冲区大小为0,其实,还是有缓冲的,大小为1

[Copy to clipboard] [ - ]CODE:#include
#include
#include
#include
#include
int main(void)
{
   fputs("stderr", stderr);       
   printf("%d\n", stderr->_IO_buf_end - stderr->_IO_buf_base);
   return 0;
}
对无缓冲的流的每次读写操作都会引起系统调用
1.4 feof的问题
CU上已经有无数的帖子在探讨feof了,这里从缓冲区的角度去考察一下.
对于一个空文件,为什么要先读一下,才能用feof判断出该文件到了结尾了呢?

[Copy to clipboard] [ - ]CODE:#include
#include
#include
#include
#include
int main(void)
{
   char buf[5];
   char buf2[10];
   fgets(buf, sizeof(buf), stdin);//输入要于4个字符才能看出效果
   puts(buf);
   //交替注释下面两行
   //stdin->_IO_read_end = stdin->_IO_read_ptr + sizeof(buf2)-2;
   stdin->_IO_read_end = stdin->_IO_read_ptr + sizeof(buf2)-1;

   fgets(buf2, sizeof(buf2), stdin);
   puts(buf2);
  
  
   if (feof(stdin))
printf("end\n");
   return 0;
}
运行上面的程序,需要输入多于4个字符,并且以连按两次ctrl+d为结束(不要按回车)
从上面的例子,可以看出,每当满足
(_IO_read_end < (_IO_buf_base-_IO_buf_end)) && (_IO_read_ptr == _IO_read_end)
时,标准I/O则认为已经到达文件末尾,feof(stdin)才会被设置
其中_IO_buf_base-_IO_buf_end是缓冲区的长度
也就是说,标准I/O是通过它的缓冲区来判断流是否要结束了的.
这就解释了为什么即使是一个空文件,标准I/O也需要读一次,才能使用feof判断释放为空
1.5. 其他说明
很多新手有一个误解,就是fgets, fputs代表行缓冲,fread, fwrite代表全缓冲 fgetc, fputc代表无缓冲
等等.
其实不是这样的,是什么样的缓冲跟使用那个函数没有关系,
而跟你读写什么类型的文件有关系.
上面的例子中多次在全缓冲中使用fgets, fputs,而在行缓冲中使用fread, fwrite
下面的是引至APUE的
实际上
ISO C要求:
1.当且仅当标准输入和标准输出并不涉及交互式设备时,他们才是全缓冲的
2.标准输出决不是全缓冲的.
很多系统默认使用下列类型的标准:
1.标准输出是不带缓冲的.
2.如若是涉及终端设备的其他流,则他们是行缓冲的;否则是全缓冲的.