浅谈无缓存I/O操作和标准I/O文件操作区别
首先，先稍微了解系统调用的概念：
系统调用，英文名system
call，每个操作系统都在内核里有一些内建的函数库，这些函数可以用来完成一些系统系统调用把应用程序的请求传给内核，调用相应的的内核函数完成所需的处理，将处理结果返回给应用程序，如果没有系统调用和内
核函数，用户将不能编写大型应用程序，及别的功能，这些函数集合起来就叫做程序接口或应用编程接口(Application
Programming
Interface，API)，我们要在这个系统上编写各种应用程序，就是通过这个API接口来调用系统内核里面的函数。如果没有系统调用，那么应用程序就失去内核的支持。
现在，再聊不带缓存的I/O操作：
linix对IO文件的操作分为不带缓存的IO操作和标准IO操作（即带缓存），刚开始，要明确以下几点：
1：不带缓存，不是直接对磁盘文件进行读取操作,像read()和write()函数，它们都属于系统调用，只不过在用户层没有缓存，所以叫做无缓存IO,但对于内核来说，还是进行了缓存，只是用户层看不到罢了。如果这一点看不懂，请看第二点；
2：带不带缓存是相对来说的，如果你要写入数据到文件上时（就是写入磁盘上），内核先将数据写入到内核中所设的缓冲储存器，假如这个缓冲储存器的长度是100个字节，你调用系统函
ssize_t write (int fd,const void * buf,size_t
写操作时，设每次写入长度count=10个字节，那么你几要调用10次这个函数才能把这个缓冲区写满，此时数据还是在缓冲区，并没有写入到磁盘，缓冲区满时才进行实际上的IO操作，把数据写入到磁盘上，所以上面说的“不带缓存不是就没有缓存直写进磁盘”就是这个意思。
那么，既然不带缓存的操作实际在内核是有缓存器的，那带缓存的IO操作又是怎么回事呢？
带缓存IO也叫标准IO，符合ANSI C
的标准IO处理，不依赖系统内核，所以移植性强，我们使用标准IO操作很多时候是为了减少对read()和write()的系统调用次数，带缓存IO其实就是在用户层再建立一个缓存区，这个缓存区的分配和优化长度等细节都是标准IO库代你处理好了，不用去操心，还是用上面那个例子说明这个操作过程：
上面说要写数据到文件上，内核缓存（注意这个不是用户层缓存区）区长度是100字节，我们调用不带缓存的IO函数write()就要调用10次，这样系统效率低，现在我们在用户层建立另一个缓存区（用户层缓存区或者叫流缓存），假设流缓存的长度是50字节，我们用标准C库函数的fwrite()将数据写入到这个流缓存区里面，流缓存区满50字节后在进入内核缓存区，此时再调用系统函数write()将数据写入到文件（实质是磁盘）上，看到这里，你用该明白一点，标准IO操作fwrite()最后还是要掉用无缓存IO操作write,这里进行了两次调用fwrite()写100字节也就是进行两次系统调用write()。
如果看到这里还没有一点眉目的话，那就比较麻烦了，希望下面两条总结能够帮上忙：
无缓存IO操作数据流向路径：数据——内核缓存区——磁盘
标准IO操作数据流向路径：数据——流缓存区——内核缓存区——磁盘
下面是一个网友的见解，以供参考：
不带缓存的I/O对文件描述符操作，下面带缓存的I/O是针对流的。
标准I/O库就是带缓存的I/O，它由ANSI
C标准说明。当然，标准I/O最终都会调用上面的I/O例程。标准I/O库代替用户处理很多细节，比如缓存分配、以优化长度执行I/O等。
标准I/O提供缓存的目的就是减少调用read和write的次数，它对每个I/O流自动进行缓存（标准I/O函数通常调用malloc来分配缓存）。它提供了三种类型的缓存：
全缓存。当填满标准I/O缓存后才执行I/O操作。磁盘上的文件通常是全缓存的。
行缓存。当输入输出遇到新行符或缓存满时，才由标准I/O库执行实际I/O操作。stdin、stdout通常是行缓存的。
无缓存。相当于read、write了。stderr通常是无缓存的，因为它必须尽快输出。
一般而言，由系统选择缓存的长度，并自动分配。标准I/O库在关闭流的时候自动释放缓存。
&&& 在标准I /
O库中，一个效率不高的不足之处是需要复制的量。
当使用每次一行函数fgets和fputs时，通常需要复制两次数据：一次是在内核和标准I /
O缓存之间（当调用read和write时），第二次是在标准I /
O缓存（通常系统分配和管理）和用户程序中的行缓存（fgets的参数就需要一个用户行缓存指针）之间。
不管上面讲的到底懂没懂，记住一点：
&&& 使用标准I /
O例程的一个优点是无需考虑缓存及最佳I / O长度的选择，并且它并不比直接调用read、write慢多少。
带缓存的文件操作是标准C 库的实现，第一次调用带缓存的文件操作时
标准库会自动分配内存并且读出一段固定大小的内容存储在缓存中。所以以后每次的读写操作并不是针对硬盘上的文件直接进行的，而是针对内存中的缓存的。何时
从硬盘中读取文件或者向硬盘中写入文件有标准库的机制控制。不带缓存的文件操作通常都是系统提供的系统调用，更加低级，直接从硬盘中读取和写入文件，由于
IO瓶颈的原因，速度并不如意，而且原子操作需要程序员自己保证，但使用得当的话效率并不差。另外标准库中的带缓存文件IO
是调用系统提供的不带缓存IO实现的。
这里为了说明标准I/O的工作原理,借用了glibc中标准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读取数据的例子:
#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
int _fileno;
上面的定义中有三组重要的字段:
char* _IO_read_
char* _IO_read_
char* _IO_read_
char* _IO_write_
char* _IO_write_
char* _IO_write_
char* _IO_buf_
char* _IO_buf_
_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
myfile-&_IO_read_base);
&&printf("read buffer length
myfile-&_IO_read_end
- myfile-&_IO_read_base);
&&printf("write buffer base
myfile-&_IO_write_base);
&&printf("write buffer length
myfile-&_IO_write_end
- myfile-&_IO_write_base);
&&printf("buf buffer base
myfile-&_IO_buf_base);
&&printf("buf buffer length
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
myfile-&_IO_read_base);
&&printf("read buffer length
myfile-&_IO_read_end
- myfile-&_IO_read_base);
&&printf("write buffer base
myfile-&_IO_write_base);
&&printf("write buffer length
myfile-&_IO_write_end
- myfile-&_IO_write_base);
&&printf("buf buffer base
myfile-&_IO_buf_base);
&&printf("buf buffer length
myfile-&_IO_buf_end
- myfile-&_IO_buf_base);
&&return 0;
可以看到,在读操作之前,myfile的缓冲区是没有被分配的,在一次读之后,myfile的缓冲区才被分配.
这个缓冲区既不是内核中的缓冲区,也不是用户分配的缓冲区,而是有用户进程空间中的由buffered
I/O系统负责维护的缓冲区.
(当然,用户可以可以维护该缓冲区,这里不做讨论了)
上面的例子只是说明了buffered I/O缓冲区的存在,下面从全缓冲,行缓冲和无缓冲3个方面看一下buffered
是如何工作的.
1.1. 全缓冲
下面是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 & 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文件的内容是由很多行的""组成
上例中,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};
&&FILE *myfile;
&&myfile = fopen("aaa.txt", "r+");
&&while (i&2048)
&&&&fwrite(buf+i,
1, 512, myfile);
&&&&//注释掉这句则可以写入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_会导致标准I/O认为
没有数据写入缓冲区,所以永远不会调用write,这样aaa.txt文件得不到写入.
注释掉myfile-&_IO_write_ptr =
myfile-&_IO_write_前后,看看效果
全缓冲写的时候:
_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的系统调用
下面两个例子会说明这个问题
第一个例子可以用来说明下面这篇帖子的问题
#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_会导致标准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的
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&//这是行缓冲跟全缓冲的重要区别
writeLog(FILE *ftmp)
&&fprintf(ftmp, "%p write buffer
stdout-&_IO_write_base);
&&fprintf(ftmp, "%p buf buffer base
stdout-&_IO_buf_base);
&&fprintf(ftmp, "%p read buffer base
stdout-&_IO_read_base);
&&fprintf(ftmp, "%p write buffer ptr
stdout-&_IO_write_ptr);
&&fprintf(ftmp, "\n");
int main(void)
&&FILE *ftmp;
&&ftmp = fopen("ccc.txt", "w");
&&while (i&4)
&&&&fwrite(buf,
1, 5, stdout);
&&&&*stdout-&_IO_write_ptr++
= '\n';//可以单独把这句打开,看看效果
&&&&//getchar();//getchar()会标准I/O将缓冲区输出
&&&&//打开下面的注释,你就会发现屏幕上什么输出也没有
&&&&//stdout-&_IO_write_ptr
= stdout-&_IO_write_
&&&&writeLog(ftmp);
//这个只是为了查看缓冲区指针的变化&&
&&return 0;
这个例子将将FILE结构中指针的变化写入的文件ccc.txt
运行后可以有兴趣的话,可以看看.
上面这个是关于行缓冲写的例子.
stdout-&_IO_write_ptr =
stdout-&_IO_write_会使得标准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
#include &stdlib.h&
#include &stdio.h&
#include &sys/types.h&
#include &sys/stat.h&
#include &fcntl.h&
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判断出该文件到了结尾了呢?
#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
&&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判断释放为空
1.5. 其他说明
很多新手有一个误解,就是fgets, fputs代表行缓冲,fread, fwrite代表全缓冲 fgetc,
fputc代表无缓冲
其实不是这样的,是什么样的缓冲跟使用那个函数没有关系,
而跟你读写什么类型的文件有关系.
上面的例子中多次在全缓冲中使用fgets, fputs,而在行缓冲中使用fread, fwrite
下面的是引至APUE的
ISO C要求:
1.当且仅当标准输入和标准输出并不涉及交互式设备时,他们才是全缓冲的
2.标准输出决不是全缓冲的.
很多系统默认使用下列类型的标准:
1.标准输出是不带缓冲的.
2.如若是涉及终端设备的其他流,则他们是行缓冲的;否则是全缓冲的.
本文仅为学习笔记，水平有限，某些概念了解可能有误，仅供参考，唔做他用。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。后使用快捷导航没有帐号？
只需一步，快速开始
网维无盘客户机缓存写满后,读取速度严重变慢，且占cpu很高！要重视起来！谢谢大家跟贴
网维小学一年级, 积分 48, 距离下一级还需 52 积分
该用户从未签到
这个问题不只是2000版才有，1.1也是一样的，我在无盘内测群说了有大半年了，也跟技术A反映过，没人理，回写一满，I7变奔腾1，那时都还以为我开玩笑呢，半年下来，我已经有十多个网吧换易游了，P事也没，网维的问题不在于有问题，而是有问题不当一回事。反正，过期就换别的，才是最明智的做法。
网维小学三年级, 积分 343, 距离下一级还需 57 积分
该用户从未签到
顶&&多开卡机 机器时间稍微长点就感觉卡&&这样的情况 也有 希望官方重视！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
网维学院三年级, 积分 7480, 距离下一级还需 32520 积分
TA的每日心情擦汗11&小时前签到天数: 474 天[LV.9]以坛为家II
官方管理员，快说个说法{:soso_e113:}
网维小学三年级, 积分 152, 距离下一级还需 248 积分
该用户从未签到
希望网维能听到群众的呼声。。。。
网维中学一年级, 积分 541, 距离下一级还需 159 积分
TA的每日心情开心 01:07签到天数: 1 天[LV.1]初来乍到
希望顺网的大大尽快解决这个问题哈。{:soso_e100:}
该用户从未签到
早就知道了，2g跟4g还是差很多的，不要以为设置大，会写数据量小宁愿回写数据量大，不能让客户机游戏内存不够啊，那更卡，现在游戏动不动就占用1g内存的。。。。一般2g设置256&&4g设置1g，速度还可以，
该用户从未签到
mnls0391 发表于
早就知道了，2g跟4g还是差很多的，不要以为设置大，会写数据量小宁愿回写数据量大，不能让客户机游戏内存不 ...
一般2g设置256&&4g设置1g，速度还可以???
你有没有试过当网维无盘客户机1G缓存写满后，读取速度是多少？只有25M左右的速度，512K值过不了50M的峰值，且占CPU很高
你看了视屏吗1G缓存的那个视屏吗？
当网维无盘客户机缓存写满后& &2g设置32M缓存&&多次随机读取速度64K值 62M左右 512k值 90M左右
2g设置256M缓存,多次随机读取速度64K值 35M-40M左右&&512k值 70M左右
4g设置1G缓存，多次随机读取速度64K值 25M左右&&512k值 50M左右
读取速度严重降低了！！！
网维学院三年级, 积分 4479, 距离下一级还需 35521 积分
该用户从未签到
本帖最后由 逍遥书生 于
14:40 编辑
xnfjr 发表于
一般2g设置256&&4g设置1g，速度还可以???
你有没有试过当网维无盘客户机1G缓存写满后，读取速度是多少？ ...
问题将在新版本解决
16:46 上传
点击文件名下载附件
39.66 KB, 下载次数: 371
该用户从未签到
本帖最后由 xnfjr 于
17:12 编辑
逍遥书生 发表于
服务端替换此文件
什么版本的，我的是1100的，2000的可以吗？放了这个能彻底解决这个问题吗？有副作用吗？放在哪个目录 客户机要解开超级升级吗？
网维学院三年级, 积分 4479, 距离下一级还需 35521 积分
该用户从未签到
xnfjr 发表于
什么版本的，我的是1100的，2000的可以吗？放了这个能彻底解决这个问题吗？有副作用吗？放在哪个目录 客 ...
适用于2000版本 1100不行
Powered by> 记录软件：ATTO Disk Benchmark
别低估成绩 和你解读8款硬盘检测软件分页浏览| 05:13&&&&【 原创】 作者： | 责编：孙玉亮&&&&&
&&&& ATTO软件也是一直被大家成为跑分王的软件，其真实表达能力并没有前面速度软件那么精准，而更多表现出来的是潜在速度，因为制作厂商最早是一家电缆光纤公司。
&&& 这款ATTO Disk Benchmark软件就是他们公司开发给客户用来测试自家产品性能的，当然可能是因为磁盘测试软件的通用性，再后来开放而且完全免费，深受厂商和用户的喜爱，至今国内也已经有了汉化版，但不保证有的朋友使用的是英文版，所以下文提供了对比翻译，供参考。
ATTO Disk Benchmark解析
ATTO Disk Benchmark软件
&&& 相信很多网友都会遇到这样的问题，就是产品在出厂标称中的读取和写入速度都比自己测试的数值大，其实厂商就是通过ATTO Benchmark软件测试得出的最大数值，这款软件可以再很多地方做手脚，不了解的朋友也容易被软件的数据所蒙蔽，例如Sandforce主控，在这款软件下如鱼得水，读写均能有超过500MB/s的表现，
ATTO Disk Benchmark软件数据模块大小设置
&&& Drive-盘符: 本次测试的逻辑驱动器盘符（也就意味着需要用ATTO做测试，必须要先把硬盘驱动器分区并给一个盘符）。
&&& Transfer Size-传输大小: 测试数据块大小，默认是从0.5KB(512B) ~ 8192KB(8MB)，当测试时，程序会测试这里所设置的数据块大小下的数据传输速度。
&&& Total Length-总长度:测试数据长度，默认是256MB，最大可以设置到，对机械硬盘来说，软件测试时，会事先生成一个为这个容量大小的测试文件，然后测试就是在这个文件内进行的。（由于SSD有FTL-逻辑物理映射层的关系，实际测试时并不是在这个文件内进行，而是取决于磨损平衡机制）
&&& Force Write Access-强制写入访问：这个功能开启时指的是，写入部分的测试数据不经过阵列卡上的数据缓存优化。
&&& Direct I/O-同步I/O：当这个功能开启时指的是，指令发出后，必须等到硬件响应才算一次IO。如果不开启（异步IO或叫缓存IO），则指令发出后，不需要等到硬件响应就可以继续发送接下去的指令，之前的指令会排序等待之后的处理，间接等于阵列卡上的数据缓存速度或者是文件系统缓存速度之一（取决于系统缓存设置）。
ATTO Disk Benchmark软件队列深度设置
I/O Comparison: 这个后面介绍
&&& Overlapped I/O（重叠I/O): 选择这个时，下面会有Queue Depth的选项，其实聪明人应该明白了，这个就是队列深度了，如果测试盘支持NCQ的话，随着队列深度的增加，性能会逐渐提升直到撑爆外部接口带宽或者内部处理速度。Neither: 选择这个就意味着跑在Queue Depth（队列深度） 1下，可以说最接近我们日常操作的情景。
&&...&&&&&&
频道热词：&&&&&&
精彩内容推荐
固态硬盘评测热点
排行 文章标题
TOP10周热门固态硬盘排行榜
商家报价：
39用户点评
商家报价：
商家报价：
118用户点评
商家报价：
118用户点评
商家报价：
36用户点评
商家报价：
商家报价：
32用户点评
商家报价：
57用户点评
商家报价：
29用户点评
商家报价：
118用户点评