深究標準IO的緩存

時間  2020-07-03
標籤 深究 標準 緩存 简体版
原文   原文鏈接

前言php

　　在最近看了APUE的標準IO部分以後感受對標準IO的緩存太模糊，沒有搞明白，APUE中關於緩存的部分一筆帶過，沒有深究緩存的實現原理，這樣一本被吹上天的書爲何不講透徹呢？今天早上爬起來趕忙找了幾篇文章看看，直到發現了這篇博客:http://blog.sina.com.cn/s/blog_6592a07a0101gar7.html。講的很不錯。html

1、IO緩存linux

　　系統調用：只操做系統提供給用戶程序調用的一組接口-------得到內核提供的服務。程序員

　　在實際中程序員使用的一般不是系統調用，而是用戶編程接口API，也稱爲系統調用編程接口。它是遵循Posix標準（Portable operation system interface），API函數可能要一個或者幾個系統調用才能完成函數功能，此函數經過c庫（libc）實現，如read，open。
　　fsync： 是把內核緩衝刷到磁盤上。
　　fflush: 是把C庫中的緩衝調用write函數寫到磁盤[實際上是寫到內核的緩衝區]。
 
　　linux對IO文件的操做分爲：
  • 不帶緩存：open  read。posix標準，在用戶空間沒有緩衝，在內核空間仍是進行了緩存的。數據-----內核緩存區----磁盤。假設內核緩存區長度爲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()(或調用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緩衝區中。在這個場景中用戶程序、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緩衝區,因此write 也不必定是直接寫到文件的,也 可能寫到內核I/O緩衝區中,可使用fsync函數同步至磁盤文件，至於究竟寫到了文件中仍是內核緩衝區中對於進程來講是沒有差異 的,若是進程A和進程B打開同一文件,進程A寫到內核I/O緩衝區中的數據從進程B也能讀到,由於內核空間是進程共享的, 而c標準庫的I/O緩衝區則不具備這一特性,由於進程的用戶空間是徹底獨立的.緩存

 

　　下面是一個利用buffered I/O讀取數據的例子: 
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

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;
#define _IO_file_flags _flags



char* _IO_read_ptr;
char* _IO_read_end;
char* _IO_read_base;
char* _IO_write_base;
char* _IO_write_ptr;
char* _IO_write_end;
char* _IO_buf_base;
char* _IO_buf_end;

char *_IO_save_base;
char *_IO_backup_base;
char *_IO_save_end;

struct _IO_marker *_markers;

struct _IO_FILE *_chain;

int _fileno;
};

　　上面的定義中有三組重要的字段:url

1.
char* _IO_read_ptr;
char* _IO_read_end;
char* _IO_read_base;
2.
char* _IO_write_base;
char* _IO_write_ptr;
char* _IO_write_end;
3.
char* _IO_buf_base;
char* _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操做時由庫函數自動申請空間,最後由相應庫函數負責釋放.(再次聲明,這裏只是glibc的實現,別的實現可能會不一樣,後面就再也不強調了)

　　請看下面的程序(這裏給的是stdin,行緩衝的例子): 
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

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系統負責維護的緩衝區.(固然,用戶能夠能夠維護該緩衝區,這裏不作討論了)spa

　　上面的例子只是說明了buffered I/O緩衝區的存在,下面從全緩衝,行緩衝和無緩衝3個方面看一下buffered I/O是如何工做的.


2、 全緩衝

　　下面是APUE上的原話:全緩衝"在填滿標準I/O緩衝區後才進行實際的I/O操做.對於駐留在磁盤上的文件一般是由標準I/O庫實施全緩衝的"書中這裏"實際的I/O操做"實際上容易引發誤導,這裏並非讀寫磁盤,而應該是進行read或write的系統調用,下面兩個例子會說明這個問題: 
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

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 <</span> 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就是用來記錄緩衝區中哪些數據是已讀的,
哪些數據是未讀的.
　　 
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(void)
{
  char buf[2048]={0};
  int i;
  FILE *myfile;
  myfile = fopen("aaa.txt", "r+");
  i= 0;
  while (i<</span>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寫入內核


3、 行緩衝

　　下面是APUE上的原話:行緩衝"當輸入輸出中遇到換行符時,標準I/O庫執行I/O操做. "書中這裏"執行O操做"也容易引發誤導,這裏不是讀寫磁盤,而應該是進行read或write的系統調用
　　下面兩個例子會說明這個問題
　　第一個例子能夠用來講明下面這篇帖子的問題
　　http://bbs.chinaunix.net/viewthread.php?tid=954547
　　 
#include <stdlib.h>
#include <stdio.h>

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是緩衝區的長度
　　 
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

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<</span>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寫入內核

4、無緩衝

　　無緩衝時,標準I/O不對字符進行緩衝存儲.典型表明是stderr。這裏的無緩衝,並非指緩衝區大小爲0,其實,仍是有緩衝的,大小爲1 
#include <</span>stdlib.h>
#include <</span>stdio.h>
#include <</span>sys/types.h>
#include <</span>sys/stat.h>
#include <</span>fcntl.h>

int main(void)
{
  fputs("stderr", stderr);
  printf("%d/n", stderr->_IO_buf_end - stderr->_IO_buf_base);

  return 0;
}

　　對無緩衝的流的每次讀寫操做都會引發系統調用


 5、 feof的問題

　　這裏從緩衝區的角度去考察一下.對於一個空文件,爲何要先讀一下,才能用feof判斷出該文件到告終尾了呢? 
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(void)
{
  char buf[5];
  char buf2[10];

  fgets(buf, sizeof(buf), stdin);//輸入要於4個,少於13個字符才能看出效果
  puts(buf);

  //交替註釋下面兩行
  //stdin->_IO_read_end = stdin->_IO_read_ptr+1;

  stdin->_IO_read_end = stdin->_IO_read_ptr + sizeof(buf2)-1;
   
  fgets(buf2, sizeof(buf2), stdin);
  puts(buf2);
  if (feof(stdin))
    printf("input end/n");
  return 0;
}

 

　　運行上面的程序,輸入多於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判斷釋放爲空。
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程