最近实验室的学弟们貌似对缓冲区很感兴趣,听到很多次在讨论缓冲区。今天也来写篇文章和大家讨论一下。从I/O,到缓冲区都会谈到。首先是所有语言都提供了执行I/O的较高级别的工具,例如ANSI C提供了标准I/O库,C++重载了<<和>>等,这些不依赖于系统内核,所以移植性强,而且这个缓冲区的分配长度和优化等细节都是代你处理好了。在Unix系统中,是通过使用有内核提供的系统级Unix I/O函数来实现这些较高级别的I/O函数的。
高级别I/O函数工作很好,上面也提到了几点优点,为什么还要学习Unix I/O呢?
- 了解Unix I/O可以帮你理解其他的系统概念。比如进程、存储器层次结构、链接和加载等。
- 有时候除了使用Unix I/O 以外别无选择。有些重要情况下,使用高级I/O函数不能实现想要的功能,比如标准I/O库没有提供读取文件元数据的方式,比如文件大小或文件创建时间等。
I/O 概念:
输入/输出(I/O)是在主存和外部设备(如磁盘驱动器、终端和网络)之间拷贝数据的过程。输入操作是从I/O设备拷贝数据到主存,而输出操作是从主存拷贝数据到I/O设备。
所有的I/O设备都被模型化为外文件,所有的输入输出都被当做对相应文件的读和写来执行。设备映射为文件,使得输入输出能够以一种统一且一致的方式来执行。
一系列的Unix I/O函数
#include <sys/type.h>
#include <sys/stat.h>
#include <fcntl.h>
int open(char *filename, int flags, mode_t mode);
//将filename转换为一个文件描述符, 成功则返回非负的新的文件描述符,出错返回-1
//flags 指明了进程如何访问这个文件
//mode 指定了新文件的访问权限位
#include <unistd.h>
int close(int fd);
//关闭此文件描述符对应的文件,成功返回09,出错返回-1
#include <unistd.h>
ssize_t read(int fd, void *buf, size_t n);
//从文件描述符为fd的当前文件位置,拷贝最多n个字节到存储器位置buf。
//成功返回实际传送的字节数,若EOF则为0,出错返回-1
#include <unistd.h>
ssize_t write(int fd, const char *buf, size_t n); //成功返回写的字节数,出错则为-1
//从存储器位置buf拷贝至多n个字节到描述符fd的当前文件位置。
//成功返回写的字节数,出错则为-1
Q:ssize_t和size_t有些什么区别?
A:size_t 被定义为 unsigned int,而ssize_t(有符号的大小)被定义为 int。read函数返回一个有符号的大小,而不是一个无符号的大小,是因为出错返回-1,这使得read的最大值减小了一半,从4G减小到了2G。
什么是“不足值”?
“不足值”的情况:指的是某些情况下,read和write传送的字节比应用程序要求的要少,这些不足值不表示有错误。
造成这种情况的原因有:
- 读时遇到EOF。要求的字节数超过了读缓冲区内未读的字节的数量。
- 从终端读取文本行。如果打开文件是与终端想关联的(比如键盘和显示器),那么每个read函数将一次传送一个文本行,返回的不足值等于文本行的大小。
- 读和写socket。内部缓冲约束和较长的网络延迟会引起read和write返回不足值。
用RIO包健壮地读写
在像网络程序这样容易出现不足值的应用中,RIO(Robust I/O)包提供了方便、健壮和高效的I/O。
RIO提供了两类不同的函数:
- 无缓冲的输入输出函数。直接在存储器和文件之间传送数据,没有应用级缓冲。对将二进制数据读写到网络和从网络中读写二进制数据尤其有用。
- 带缓冲的输入函数。允许你高效地从文件中读取文本行和二进制数据,这些内容缓存在应用级缓冲区内。带缓冲的RIO输入函数是线程安全的,允许在同一个文件描述符上被交替地调用。
带缓冲I/O和不带缓冲I/O有什么区别?
所谓不带缓冲,并不是内核不提供缓冲,系统内核对磁盘的读写都会提供一个块缓冲(也有人称为内核高速缓存),当调用一次read或write函数,直接进行系统调用,将数据写入到块缓冲进行排队。因此所谓的不带缓冲的I/O是指进程不提供缓冲功能,内核还是提供缓冲的。
而带缓冲的I/O是指进程对输入输出流进行了改进,比如调用标准I/O库函数往磁盘写数据时,标准IO库提供了一个流缓冲,先把数据写入流缓冲区中,当达到一定条件,比如流缓冲区满了或者手动刷新了流缓冲,这时候才会把数据一次送往内核提供的缓冲,再经块缓冲写入磁盘。
因此,带缓冲I/O一般会比不带缓冲I/O调用系统调用的次数要少。
ssize_t write(int filedes, const void *buff, size_t nbytes)
size_t fwrite(const void *ptr, size_t size, size_t nobj, FILE *fp)
拿这两个函数来说,首先要清楚,所谓的带缓冲并不是指上面两个函数的buff参数。
现在假设内核设的缓存是100字节,如果你使用write,且buff的size是10字节,当你要把10个同样的buff写到文件时,需要调用10次write,也就是10次系统调用,此时因为延迟写的技术,并没有写到硬盘,如果想立即写入硬盘,需调用fsync。(涉及写操作机制几个概念,同步写机制、延迟写机制、异步写机制,此处不说了,可以查一下)
标准I/O,也就是带缓存的IO,也称为用户态的缓存,区别于内核所设的缓存。假设缓存长度为50字节,把100字节的数据写到文件,只需2次系统调用,因为先把数据写到流缓存,当其满或者手动刷新之后才填入内核缓存,所以2次就够了。
至于究竟写到了文件中还是内核缓冲区中,对于进程来说是没有差别的,如果进程A和进程B打开同一文件,进程A写到内核缓冲区中的数据从进程B也能读到,因为内核空间是进程共享的。
C标准库这类缓冲区不具有这一特性,因为进程的用户空间是独立的。
下面具体来看RIO 是怎么实现的。
RIO的无缓冲输入输出函数
/*
* 无缓冲输入函数
* 成功返回收入的字节数
* 若EOF返回0 ,出错返回-1
*/
ssize_t rio_readn(int fd, void *usrbuf, size_t n)
{
size_t nleft = n;
ssize_t nread = 0;
char *pbuf = usrbuf;
while(nleft > 0){
//在某些系统中,当处理程序捕捉到一个信号时,被中断的系统调用(read write accept)
//在信号处理程序返回时不再继续,而是立即返回给客户一个错误条件,并将errno设置成为EINTR
if((nread = read(fd, pbuf,nleft)) == -1){
if(errno == EINTR){
nread = 0; //中断造成的,再次调用read
} else{
return -1; //出错
}
}
else if(nread == 0) //到了文件末尾
break;
nleft -=nread;
pbuf += nread;
}
return n-nleft;
}
/*
* 无缓冲输出函数
* 成功返回输出的字节数,出错返回-1
*/
ssize_t rio_writen(int fd, void *usrbuf, size_t n)
{
size_t nleft = n;
ssize_t nwritten;
char *bufp = usrbuf;
while(nleft > 0){
//这里是小于等于,磁盘已满或者超过一个给定进程的文件长度限制就出错了
if((nwritten = write(fd, bufp, nleft )) <= 0)
{
if(errno == EINTR)
nwritten = 0;
else
return -1;
}
nleft -=nwritten;
bufp += nwritten;
}
return n; // write 不会返回不足值
}
RIO的带缓冲输入函数
每次调用 read 都会陷入内核态,频繁的调用效率不是很高。更好的方法就是调用一个包装函数,它从一个内部读缓冲区拷贝数据,当缓冲区变空时,会自动地调用 read 重新填满缓冲区。
#define RIO_BUFSIZE 8192
typedef struct {
int rio_fd; //内部读缓冲区描述符
int rio_cnt; //内部缓冲区中未读字节数
char *rio_bufptr; //内部缓冲区中下一个未读的字节
char rio_buf[RIO_BUFSIZE]; //内部读缓冲区
}rio_t; //一个类型为rio_t的读缓冲区
// 初始化rio_t结构,创建一个空的读缓冲区
// 将fd和地址rp处的这个读缓冲区联系起来
void rio_readinitb(rio_t *rp, int fd)
{
rp -> rio_fd = fd;
rp -> rio_cnt = 0;
rp -> rio_bufptr = rp -> rio_buf;
}
//是 RIO 读程序的核心,是Unix read函数的带缓冲的版本,供内部调用
ssize_t rio_read(rio_t *rp, char *usrbuf, size_t n)
{
int cnt;
while(rp -> rio_cnt <= 0){ //内部缓冲区空了,重新填
rp -> rio_cnt = read(rp -> rio_fd, rp -> rio_buf, sizeof(rp -> rio_buf));
if(rp -> rio_cnt < 0){
if(errno != EINTR) //出错返回
return -1;
}
else if(rp -> rio_cnt == 0) //EOF
return 0;
else
rp -> rio_bufptr = rp -> rio_buf; //重置指针位置
}
//从内部缓冲区拷贝到用户缓冲区中
cnt = (rp -> rio_cnt < n) ? rp -> rio_cnt : n;
memcpy(usrbuf, rp -> rio_bufptr, cnt);
rp -> rio_bufptr += cnt;
rp -> rio_cnt -= cnt;
return cnt;
}
//带缓冲输入函数,每次输入一行
//从文件rp读出一个文本行(包括结尾的换行符),将它拷贝到usrbuf,并且用空字符来结束这个文本行
//最多读maxlen-1个字节,余下的一个留给结尾的空字符
ssize_t rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen)
{
int rc,n;
char c,*bufp = usrbuf;
for(n = 1; n<maxlen; n++){
if((rc = rio_read(rp, &c, 1)) == 1){ //每次读取一个字符
*bufp++ = c;
if(c == '\n')
break;
} else if(rc == 0){
if(n == 1) //空文件
return 0;
else
break; //读到部分数据
} else
return -1; //出错
}
*bufp = '\0'; //添加字符串结尾符
return n-1;
}
//带缓冲输入函数
ssize_t rio_readnb(rio_t *rp, void *usrbuf, size_t n)
{
size_t nleft = n;
ssize_t nread;
char *bufp = usrbuf;
while(nleft > 0){
if((nread = rio_read(rp, bufp, nleft)) < 0)
return -1; //出错
} else if( nread == 0 )
break; //EOF
nleft -= nread;
bufp += nread;
}
return (n - nleft);
}
实现过程参考 CSAPP 第十章内容。
为什么rio_writen()不需要缓冲呢?
假设将一个HTTP请求写到对应socket的文件描述符的缓冲区,假设缓冲区大小为8K,该请求报文大小为1K,那么如果缓冲区被设置为只有填满才会真正被写入文件,那就是说如果没有提供一个刷新缓冲区的函数手动刷新,还需要额外发送7K的数据将缓冲区填满,这个报文才能真正被写入到socket中。
所以一般带有缓冲区的函数库都会有一个刷新缓冲区的函数,用于将在缓冲区的数据真正写入文件当中,即使缓冲区没有被填满,这正是C标准库的做法。然而如果程序开发人员不小心忘记在写入操作完成后手动刷新,那么该数据便一直驻留在缓冲区,进程也会被阻塞。
做网络应用程序应该用什么I/O函数?
Unix对网络的抽象是一种称为套接字的文件类型,也是文件描述符。标准I/O流,程序能够在同一个流上执行输入和输出,因此从某种意义上来说是全双工的。然后,对流的限制和对套接字的限制,有时候会互相冲突。比如下面两个限制:
- 如果中间没有插入对fflush、fseek、fsetpos或者rewind的调用,一个输入函数不能跟随在一个输出函数之后。fflush是清空流缓冲区,后三个函数使用 Unix I/O lseek 函数重置当前的文件位置。
- 如果中间没有插入对fseek、fsetpos或者rewind的调用,一个输出函数不能跟随在一个输入函数之后,除非输入函数入到EOF。
在开发网络应用中,对套接字使用 lseek 是非法的。因此对上面限制1 来说还可以采用刷新缓冲区来满足;然而对第二个限制的唯一办法是,对同一个打开的套接字描述符打开两个流,一个用来读,一个用来写。
但是它要求应用程序在两个流上都要调用 fclose,这样才能释放相关存储器资源,多个操作试图关闭同一个描述符,第二个close就会失败,在线程化程序中关闭一个已经关闭了的描述符是会导致灾难的。
引用书上原文:
因此,我们建议你在网络套接字上不要使用标准I/O函数来进行输入和输出。而要使用健壮的RIO函数。如果需要使用格式化的输出,使用 sprintf 函数在存储器中格式化一个字符串,然后用 rio_writen 把它发送到套接口。如果需要格式化输入,使用 rio_readlineb 来读一个完整的文本行,然后用 sscanf 从文本行提取不同的字段。
来源:oschina
链接:https://my.oschina.net/u/4279909/blog/4779269