深究标准IO的缓存

深究标准IO的缓存,第1张

概述前言 在最近看了APUE的标准IO部分之后感觉对标准IO的缓存太模糊,没有搞明白,APUE中关于缓存的部分一笔带过,没有深究缓存的实现原理,这样一本被吹上天的书为什么不讲透彻呢?今天早上爬起来赶紧找了

前言@H_404_4@

  在最近看了APUE的标准IO部分之后感觉对标准IO的缓存太模糊,没有搞明白,APUE中关于缓存的部分一笔带过,没有深究缓存的实现原理,这样一本被吹上天的书为什么不讲透彻呢?今天早上爬起来赶紧找了几篇文章看看,直到发现了这篇博客:http://blog.sina.com.cn/s/blog_6592a07a0101gar7.HTML。讲的很不错。

一、IO缓存@H_404_4@

  系统调用:只 *** 作系统提供给用户程序调用的一组接口-------获得内核提供的服务。

  在实际中程序员使用的通常不是系统调用,而是用户编程接口API,也称为系统调用编程接口。它是遵循Posix标准(Portable operation system interface),API函数可能要一个或者几个系统调用才能完成函数功能,此函数通过c库(libc)实现,如read,open。  fsync:是把内核缓冲刷到磁盘上。@H_404_4@  fflush:是把C库中的缓冲调用write函数写到磁盘[其实是写到内核的缓冲区]。@H_404_4@   linux对IO文件的 *** 作分为:不带缓存:open  read。posix标准,在用户空间没有缓冲,在内核空间还是进行了缓存的@H_404_4@。数据-----内核缓存区----磁盘。假设内核缓存区长度为100字节,你调用ssize_t write (int fd,const voID * buf,size_t count);写 *** 作时,设每次写入count=10字节,那么你要调用10次这个函数才能把这个缓存区写满,没写满时数据还是在内核缓冲区中,并没有写入到磁盘中,内核缓存区满了之后或者执行了fsync(强制写入硬盘)之后,才进行实际的IO *** 作,吧数据写入磁盘上。带缓存区:fopen fwrite fget 等,是c标准库中定义的。数据-----流缓存区-----内核缓存区----磁盘。假设流缓存区长度为50字节,内核缓存区100字节,我们用标准c库函数fwrite()将数据写入到这个流缓存中,每次写10字节,需要写5次流缓存区满后调用write()(或@H_404_4@@H_404_4@调用@H_404_4@fflush()),将数据写到内核缓存区,直到内核缓存区满了之后或者执行了fsync(强制写入硬盘)之后,才进行实际的IO *** 作,吧数据写入磁盘上。标准IO *** 作fwrite()最后还是要掉用无缓存IO *** 作write。

  以fgetc / fputc 为例,当用户程序第一次调用fgetc 读一个字节时,fgetc 函数可能通过系统调用 进入内核读1K字节到I/O缓冲区中,然后返回I/O缓冲区中的第一个字节给用户,把读写位置指 向I/O缓冲区中的第二个字符,以后用户再调fgetc,就直接从I/O缓冲区中读取,而不需要进内核 了,当用户把这1K字节都读完之后,再次调用fgetc 时,fgetc 函数会再次进入内核读1K字节 到I/O缓冲区中。@H_404_4@在这个场景中用户程序、C标准库和内核之间的关系就像在“Memory HIErarchy”中 cpu、Cache和内存之间的关系一样,C标准库之所以会从内核预读一些数据放 在I/O缓冲区中,是希望用户程序随后要用到这些数据,C标准库的I/O缓冲区也在用户空间,直接 从用户空间读取数据比进内核读数据要快得多。另一方面,用户程序调用fputc 通常只是写到I/O缓 冲区中,这样fputc 函数可以很快地返回,如果I/O缓冲区写满了,fputc 就通过系统调用把I/O缓冲 区中的数据传给内核,内核最终把数据写回磁盘或设备。有时候用户程序希望把I/O缓冲区中的数据立刻 传给内核,让内核写回设备或磁盘,这称为Flush *** 作,对应的库函数是fflush,fclose函数在关闭文件 之前也会做Flush *** 作。

  虽然write 系统调用位于C标准库I/O缓冲区的底 层,被称为Unbuffered I/O函数,但在write 的底层也可以分配一个内核I/O缓冲区@H_404_4@,所以write 也不一定是直接写到文件的,也 可能写到内核I/O缓冲区中,可以使用fsync函数同步至磁盘文件,至于究竟写到了文件中还是内核缓冲区中对于进程来说是没有差别 的,如果进程A和进程B打开同一文件,进程A写到内核I/O缓冲区中的数据从进程B也能读到,因为内核空间是进程共享的,而c标准库的I/O缓冲区则不具有这一特性,因为进程的用户空间是完全独立的.

 

  下面是一个利用buffered I/O读取数据的例子:
#include <stdlib.h>#include @H_404_4@<stdio.h>#include @H_404_4@<sys/types.h>#include @H_404_4@<sys/stat.h>#include @H_404_4@<fcntl.h>int@H_404_4@ main(voID@H_404_4@){  @H_404_4@char@H_404_4@ buf[5@H_404_4@];  file @H_404_4@*myfile = stdin;  fgets(buf,@H_404_4@,myfile);  fputs(buf,myfile);    @H_404_4@return@H_404_4@ 0@H_404_4@;}@H_404_4@

  buffered I/O中的"buffer"到底是指什么呢?这个buffer在什么地方呢?file是什么呢?它的空间是怎么分配的呢  要弄清楚这些问题,就要看看file是如何定义和运作的了.(特别说明,在平时写程序时,不用也不要关心file是如何定义和运作的,最好不要直接 *** 作它,这里使用它,只是为了说明buffered IO)下面的这个是glibc给出的file的定义,它是实现相关的,别的平台定义方式不同.

struct@H_404_4@ _IO_file {@H_404_4@int@H_404_4@ _flags;@H_404_4@#define@H_404_4@ _IO_file_flags _flagschar@H_404_4@* _IO_read_ptr;@H_404_4@ _IO_read_end;@H_404_4@ _IO_read_base;@H_404_4@ _IO_write_base;@H_404_4@ _IO_write_ptr;@H_404_4@ _IO_write_end;@H_404_4@ _IO_buf_base;@H_404_4@ _IO_buf_end;@H_404_4@char@H_404_4@ *_IO_save_base;@H_404_4@_IO_backup_base;@H_404_4@_IO_save_end;@H_404_4@struct@H_404_4@ _IO_marker *_markers;@H_404_4@struct@H_404_4@ _IO_file *_chain;@H_404_4@ _fileno;};@H_404_4@

  上面的定义中有三组重要的字段:

1@H_404_4@.@H_404_4@ _IO_read_base;@H_404_4@2@H_404_4@ _IO_write_end;@H_404_4@3@H_404_4@char@H_404_4@* _IO_buf_end;
  其中,
  _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 I/O *** 作时由库函数自动申请空间,最后由相应库函数负责释放@H_404_4@.(再次声明,这里只是glibc的实现,别的实现可能会不同,后面就不再强调了)

  请看下面的程序(这里给的是stdin,行缓冲的例子):
#include <stdlib.h>stdin;  printf(@H_404_4@"@H_404_4@before reading/n@H_404_4@"@H_404_4@);  printf(@H_404_4@read buffer base %p/n@H_404_4@"@H_404_4@,myfile->_IO_read_base);  printf(@H_404_4@read buffer length %d/n@H_404_4@write buffer base %p/n@H_404_4@_IO_write_base);  printf(@H_404_4@write buffer length %d/n@H_404_4@buf buffer base %p/n@H_404_4@_IO_buf_base);  printf(@H_404_4@buf buffer length %d/n@H_404_4@/n@H_404_4@);  fgets(buf,myfile);  printf(@H_404_4@after reading/n@H_404_4@_IO_buf_base);  @H_404_4@;}@H_404_4@

  可以看到,在读 *** 作之前,myfile的缓冲区是没有被分配的,在一次读之后,myfile的缓冲区才被分配.这个缓冲区既不是内核中的缓冲区,也不是用户分配的缓冲区,而是有用户进程空间中的由buffered I/O系统负责维护的缓冲区.(当然,用户可以可以维护该缓冲区,这里不做讨论了)

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


二、 全缓冲@H_404_4@

  下面是APUE上的原话:全缓冲"在填满标准I/O缓冲区后才进行实际的I/O *** 作.对于驻留在磁盘上的文件通常是由标准I/O库实施全缓冲的"书中这里"实际的I/O *** 作"实际上容易引起误导,这里并不是读写磁盘,而应该是进行read或write的系统调用,下面两个例子会说明这个问题:
#include <stdlib.h>];  @H_404_4@cur;  file @H_404_4@*myfile;  myfile @H_404_4@= fopen(bbb.txt@H_404_4@r@H_404_4@before reading,myfile->_IO_read_ptr: %d/n@H_404_4@_IO_read_base);  fgets(buf,1)">5@H_404_4@,myfile); //@H_404_4@仅仅读4个字符@H_404_4@  cur = myfile->_IO_read_base;  @H_404_4@while@H_404_4@ (cur <</span> myfile->_IO_read_end) 实际上读满了这个缓冲区@H_404_4@  {    printf(@H_404_4@%c@H_404_4@cur);    cur@H_404_4@++;  }  printf(@H_404_4@/nafter reading,1)">_IO_read_base);  @H_404_4@;}@H_404_4@

  上面提到的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就是用来记录缓冲区中哪些数据是已读的,
哪些数据是未读的.  
#include <stdlib.h>2048@H_404_4@]={};  @H_404_4@ i;  file @H_404_4@*aaa.txt@H_404_4@r+@H_404_4@);  i@H_404_4@= ;  @H_404_4@while@H_404_4@ (i<</span>2048@H_404_4@)  {    fwrite(buf@H_404_4@+i,1)">1@H_404_4@,1)">512@H_404_4@;    @H_404_4@注释掉这句则可以写入aaa.txt@H_404_4@    myfile->_IO_write_ptr = myfile->_IO_write_base;    printf(@H_404_4@%p write buffer base/n@H_404_4@_IO_write_base);    printf(@H_404_4@%p buf buffer base /n@H_404_4@_IO_buf_base);    printf(@H_404_4@%p read buffer base /n@H_404_4@_IO_read_base);    printf(@H_404_4@%p write buffer ptr /n@H_404_4@_IO_write_ptr);    printf(@H_404_4@);  }  @H_404_4@;}@H_404_4@

  上面这个是关于全缓冲写的例子.全缓冲时,只有当标准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写入内核


三、 行缓冲@H_404_4@

  下面是APUE上的原话:行缓冲"当输入输出中遇到换行符时,标准I/O库执行I/O *** 作. "书中这里"执行O *** 作"也容易引起误导,这里不是读写磁盘,而应该是进行read或write的系统调用
  下面两个例子会说明这个问题
  第一个例子可以用来说明下面这篇帖子的问题
  http://bbs.chinaunix.net/viewthread.php?tid=954547
  
#include <stdlib.h>#include @H_404_4@<stdio.h>char@H_404_4@ buf2[10@H_404_4@];    fgets(buf,stdin); 第一次输入时,超过5个字符@H_404_4@  puts(stdin@H_404_4@->_IO_read_ptr);本句说明整行会被一次全部读入缓冲区,@H_404_4@而非仅仅上面需要的个字符@H_404_4@  stdin->_IO_read_ptr = stdin->_IO_read_end; 标准I/O会认为缓冲区已空,再次调用read                                             @H_404_4@注释掉,再看看效果@H_404_4@  printf();  puts(buf);    fgets(buf2,stdin);  puts(buf2);    @H_404_4@;}@H_404_4@

  上例中,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是缓冲区的长度
  
#include <stdlib.h>5@H_404_4@]={'@H_404_4@1@H_404_4@'@H_404_4@,1)">2@H_404_4@3@H_404_4@4@H_404_4@5@H_404_4@'@H_404_4@}; 最后一个不要是/n,是/n的话,标准I/O会自动flush的                                                    @H_404_4@这是行缓冲跟全缓冲的重要区别@H_404_4@voID@H_404_4@ writeLog(file *ftmp){  fprintf(ftmp,stdout->_IO_write_base);  fprintf(ftmp,1)">_IO_buf_base);  fprintf(ftmp,1)">_IO_read_base);  fprintf(ftmp,1)">_IO_write_ptr);  fprintf(ftmp,1)">);}@H_404_4@ftmp;  ftmp @H_404_4@= fopen(ccc.txt@H_404_4@w@H_404_4@4@H_404_4@)  {    fwrite(buf,stdout);    i@H_404_4@++;    @H_404_4@*stdout->_IO_write_ptr++ = '@H_404_4@;可以单独把这句打开,看看效果    @H_404_4@getchar();@H_404_4@getchar()会标准I/O将缓冲区输出    @H_404_4@打开下面的注释,你就会发现屏幕上什么输出也没有    @H_404_4@stdout->_IO_write_ptr = stdout->_IO_write_base;@H_404_4@    writeLog(ftmp); 这个只是为了查看缓冲区指针的变化  @H_404_4@  }  @H_404_4@;}@H_404_4@

  这个例子将将file结构中指针的变化写入的文件ccc.txt,@H_404_4@

  运行后可以有兴趣的话,可以看看.

  上面这个是关于行缓冲写的例子.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写入内核

四、无缓冲@H_404_4@
  无缓冲时,标准I/O不对字符进行缓冲存储.典型代表是stderr。这里的无缓冲,并不是指缓冲区大小为0,其实,还是有缓冲的,大小为1
#include <</span>stdlib.h>#include @H_404_4@<</span>stdio.h>#include @H_404_4@<</span>sys/types.h>#include @H_404_4@<</span>sys/stat.h>#include @H_404_4@<</span>fcntl.h>){  fputs(@H_404_4@stderr@H_404_4@%d/n@H_404_4@;}@H_404_4@

  对无缓冲的流的每次读写 *** 作都会引起系统调用


五、 feof的问题@H_404_4@

  这里从缓冲区的角度去考察一下.对于一个空文件,为什么要先读一下,才能用feof判断出该文件到了结尾了呢?
#include <stdlib.h>];  fgets(buf,1)">sizeof@H_404_4@(buf),stdin);输入要于4个,少于13个字符才能看出效果@H_404_4@  puts(buf);  @H_404_4@交替注释下面两行  @H_404_4@stdin->_IO_read_end = stdin->_IO_read_ptr+1;@H_404_4@  stdin@H_404_4@->_IO_read_end = stdin->_IO_read_ptr + sizeof@H_404_4@(buf2)-;     fgets(buf2,1)">sizeof@H_404_4@(buf2),stdin);  puts(buf2);  @H_404_4@if@H_404_4@ (feof(stdin))    printf(@H_404_4@input end/n@H_404_4@);  @H_404_4@;}@H_404_4@

 

  运行上面的程序,输入多于4个,少于13个字符,并且以连按两次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判断释放为空。@H_404_4@ 总结

以上是内存溢出为你收集整理的深究标准IO的缓存全部内容,希望文章能够帮你解决深究标准IO的缓存所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错,欢迎将内存溢出网站推荐给程序员好友。

欢迎分享,转载请注明来源:内存溢出

原文地址: http://outofmemory.cn/yw/1016436.html

(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022-05-22
下一篇 2022-05-22

发表评论

登录后才能评论

评论列表(0条)

保存