Пользовательская буферизация

So perform all your I/O in 4 or 8KB chunks and everything is great? Not so fast. The
problem, of course, is that programs rarely deal in terms of blocks. Programs work with
fields, lines, and single characters, not abstractions such as blocks. User-buffered I/O
closes the gap between the filesystem, which speaks in blocks, and the application, which
talks in its own abstractions. How it works is simple, yet very powerful: as data is written,
it is stored in a buffer inside the program’s address space. When the buffer reaches a set
size, called the buffer size, the entire buffer is written out in a single write operation.
Likewise, data is read using buffer-sized, block-aligned chunks. The application’s
various-sized read requests are served not directly from the filesystem, but via the
chunks of the buffer. As the application reads more and more, data is handed out from
the buffer piece-by-piece. Ultimately, when the buffer is empty, another large block-
aligned chunk is read in. In this manner, although the application reads and writes in
whatever odd sizes it chooses, data is buffered such that only large, block-aligned reads
and writes are actually issued to the filesystem. The end result is fewer system calls for
larger amounts of data, all aligned on block boundaries. Huge performance benefits
ensue.
It is possible to implement user buffering by hand in your own programs. Indeed, many
mission-critical applications do just that. The vast majority of programs, however, make
use of the popular standard I/O library (part of the standard C library) or the iostream
library (part of the standard C++ library), which provides a robust and capable user-
buffering solution.