Buffer and Cache Definitions:

Buffer: A temporary storage for raw disk blocks, which writes cached data to disk. It is usually not very large (around 20MB). This allows the kernel to consolidate scattered writes, optimizing disk writes uniformly. For example, multiple small writes can be combined into a single large write.
Cache: A page cache used for reading files from disk, caching data read from files. This way, when accessing these file data next time, it can be quickly retrieved from memory without needing to access the slow disk again.

But let me ask you, since Buffer is just a cache for data written to disk. Conversely, does it also cache data read from the disk? Or is Cache a cache for data read from files, does it also cache data written to files?

If you can answer the above two questions, you can skip this article; I think you already have a good understanding of Buffer and Cache. But if you cannot, please stay and see my further explanation.

free Command

To check the system memory usage, the first command that might come to mind is free, for example:

$ free -h total used free shared buff/cache availableMem: 1.9G 1.0G 394M 2.6M 491M 728MSwap: 0B 0B 0B

Clearly, the output includes the specific usage of physical memory Mem and Swap (such as total memory, used memory, cache, available memory, etc.). The cache is the sum of Buffer and Cache.

Let’s look at the definitions of Buffer and Cache in the manual page of free:

buffers Memory used by kernel buffers (Buffers in /proc/meminfo)cache Memory used by the page cache and slabs (Cached and SReclaimable in /proc/meminfo)buff/cache Sum of buffers and cache

We can see that the source data for the free command is actually stored in the proc/meminfo file. As I mentioned earlier, /proc is a special filesystem provided by the Linux kernel, acting as an interface for users to interact with the kernel.

/proc filesystem is also the ultimate data source for many performance tools. In man proc, the definitions of Buffers and Cached are as follows:

Buffers %lu Relatively temporary storage for raw disk blocks that shouldn't get tremendously large (20MB or so).Cached %lu In-memory cache for files read from the disk (the page cache). Doesn't include SwapCached....SReclaimable %lu (since Linux 2.6.19) Part of Slab, that might be reclaimed, such as caches. SUnreclaim %lu (since Linux 2.6.19) Part of Slab, that cannot be reclaimed on memory pressure.

At this point, you might think you have found the answer to my question, “Buffer” is just a cache for writing data to disk, and “Cache” is just a cache for reading data from files. But in fact, “Buffer” can also be used for reading, and “Cache” can also be used for writing.

Experiments

We will conduct two experiments here, write cache and read cache.

Writing to Cache

Let’s log into our Linux host and prepare two terminals. In Terminal 1, let’s first clear the cache:

Here, /proc/sys/vm/drop_caches is an example of modifying kernel behavior through the proc filesystem. Writing 3 means clearing various caches, such as file pages, directory entries, and inodes.

Still in Terminal 1, let’s start the vmstat 2 command:

buff and cache are what we saw earlier as Buffer and Cache, measured in KB.
bi and bo represent the size of blocks read and written to the block device, measured in blocks/s. Since the block size in Linux is 1KB, this unit is equivalent to KB/s.

Next, switch to Terminal 2 and run the following command:

Now switch back to Terminal 1 and observe the changes in buff and cache:

By observing the output of vmstat, we find that while running the dd command, the Cache kept increasing, while the Buffer remained basically unchanged.

Reading from Buffer

Now, let’s conduct the second experiment. Again, clear the cache in Terminal 1:

Also in Terminal 1, start the vmstat 2 command again:

You can see that at this point, buff is 0. Now in Terminal 2, run the following command:

Then, return to Terminal 1 and observe:

Observe the output of vmstat, you will find that when reading from the disk (i.e., when bi > 0), both Buffer and Cache are increasing, but clearly, the increase in Buffer is much faster. This means that when reading from the disk, the data is cached in the Buffer.

Now we can almost conclude:

Data is cached in Cache when reading files, and cached in Buffer when reading from the disk.

Conclusion

Here you should find that although this article describes Buffer and Cache, it still cannot cover all details. We have learned the following two points:

Buffer: Can be used as both a “cache for data to be written to disk” and a “cache for data read from the disk.”
Cache: Can be used as both a “page cache for reading files” and a “page cache for writing files.”

Disclaimer:The articles published by this public account are either original or edited and organized from excellent articles found online. The copyright of the articles belongs to the original authors and is for readers’ learning and reference only. For shared non-original articles, some may not have a true source. If the source is misattributed or if there are any infringements regarding images, links, etc., please contact the backend directly, specifying the article in question, and the backend will delete it as soon as possible. We apologize for any inconvenience caused.

Buffers and Caches in Linux Memory