Home PC Games Linux Windows Database Network Programming Server Mobile  
           
  Home \ Linux \ The difference between free command displays the buffers and cache     - Binary tree traversal recursive and non-recursive (cyclic) traversal achieve (Programming)

- Sshuttle A VPN-based transparent proxy that uses ssh (Server)

- HAproxy let IP recording back-end RS (Server)

- php for Linux the MySQL extension module installation and configuration (Database)

- GAMIT10.5 under CentOS installation (Linux)

- How do I use Linux development environment (Linux)

- How to install Perl modules from CPAN (Linux)

- Those functions under Linux you do not know the df command (Linux)

- AFNetworking + Nginx HTTPS communication server + (Server)

- Understanding the type in C ++ bitset (Programming)

- Python is not C (Programming)

- EXP-00091: Exporting questionable statistics Processing Method (Database)

- Simple security measures to reinforce the Linux kernel (Linux)

- Linux monitoring tools introduced series --smem (Server)

- Enterprise Hadoop cluster architecture - DNS installation (Server)

- Linux mount command Detailed (Linux)

- Linux user login and IP restrictions (Linux)

- After installation of Debian 6.0 do a few things first (Linux)

- SecureCRT session buffer size settings (Linux)

- Java annotations entry automatically generates SQL statements (Programming)

 
         
  The difference between free command displays the buffers and cache
     
  Add Date : 2018-11-21      
         
         
         
  It is said that very few people can say clearly distinguish free command displays the "buffers" and "cached" between:

# Free
            total used free shared buffers cached
Mem: 3848656 2983016 865640 5312 324432 2024904
- / + Buffers / cache: 633680 3214976
Swap: 2031612 0 2031612

We listed first conclusion, if you are interested in the research process can continue reading the following paragraphs:
"Buffers", a block device (block device) occupied by cached pages, including: direct block device to read and write, as well as file system metadata (metadata) such as SuperBlock used cached pages;
"Cached" represents ordinary file data occupied by cached pages.

Here is the analysis: start start with strace command track free, see if I can find out how it is to calculate the "buffers" and "cached" in:

# Strace free
...
open ( "/ proc / meminfo", O_RDONLY) = 3
lseek (3,0, SEEK_SET) = 0
read (3, "MemTotal: 3848656 kB \ nMemF" ..., 2047) = 1170
...

Obviously free command is to read information from / proc / meminfo in, with the results of our direct read as:

# Cat / proc / meminfo
MemTotal: 3848656kB
MemFree: 865640kB
Buffers: 324432kB
Cached: 2024904kB
...
SwapTotal: 2031612kB
SwapFree: 2031612kB
...
Shmem: 5312kB
...

So / proc / meminfo The "Buffers" and "Cached" is how come it? This time can not be lazy, only to see the source code. Source code files are: fs / proc / meminfo.c, the function we are interested in: meminfo_proc_show (), that read:

"Buffers" from nr_blockdev_pages () return value.
"Cached" derived from the following formula:
global_page_state (NR_FILE_PAGES) - total_swapcache_pages - i.bufferram
In the above calculation formula cached, global_page_state (NR_FILE_PAGES) from vmstat [NR_FILE_PAGES], represents the sum of all the cached pages (page cache), which comprises:

Cached
buffers
Swap cache (swap cache)
Here briefly explain swap cache:

Those anonymous memory pages, such as user processes by malloc () allocated memory pages are not associated with any file (as opposed to backing storage disk-based file memory pages), if the paging swapping occurs, this type of memory page is written exchange zone. From an anonymous memory page is determined to be feed start, it was included in the swap cache, but will not necessarily be immediately written to the physical exchange zone, because Linux is the principle unless absolutely necessary, to avoid I / O. So swap cache included are sure you want to change page swapping, but not yet written anonymous physical memory page swap area.

vmstat [NR_FILE_PAGES] can be viewed through the / proc / vmstat, it represents the total number of all cached pages:

# Cat / proc / vmstat
...
nr_file_pages587334
...

Note that the above is nr_file_pages page as a unit, rather than the free command is kilobytes (KB), a page is equal to 4KB.

Nr_file_pages directly modify the kernel functions are:
__inc_zone_page_state (page, NR_FILE_PAGES) and
__dec_zone_page_state (page, NR_FILE_PAGES),
One for increasing and one for reducing.

Look at the "cached":
"Cached" is to remove the number of "buffers" and "swap cache" outside the cache page:
global_page_state (NR_FILE_PAGES) - total_swapcache_pages - i.bufferram
So the key is to understand the "buffers" what is the meaning.

Look at the "buffers":
We see from the source code, the return value "buffers" from nr_blockdev_pages (), we look at this function is doing:

longnr_blockdev_pages (void)
{
        structblock_device * bdev;
        longret = 0;
        spin_lock (& ​​bdev_lock);
        list_for_each_entry (bdev, & all_bdevs, bd_list) {
                ret + = bdev-> bd_inode-> i_mapping-> nrpages;
        }
        spin_unlock (& ​​bdev_lock);
        returnret;
}

This code is very simple, which means through all block devices (block device), the cumulative number of pages in each block i_mapping device inode, statistical get is buffers. So obviously, buffers and block devices is directly related.

So who will update the number of cached pages block device (nrpages) it? We continue to look down.

Search kernel source code is found, the final update mapping-> function is add_to_page_cache and __remove_from_page_cache nrpages fields:

staticinline intadd_to_page_cache (structpage * page,
                structaddress_space * mapping, pgoff_t offset, gfp_t gfp_mask)
{
        interror;
 
        __set_page_locked (page);
        error = add_to_page_cache_locked (page, mapping, offset, gfp_mask);
        if (unlikely (error))
                __clear_page_locked (page);
        returnerror;
}
 
voidremove_from_page_cache (structpage * page)
{
        structaddress_space * mapping = page-> mapping;
        void (* freepage) (structpage *) = NULL;
        structinode * inode = mapping-> host;
 
        BUG_ON (! PageLocked (page));
 
        if (IS_AOP_EXT (inode))
                freepage = EXT_AOPS (mapping-> a_ops) -> freepage;
 
        spin_lock_irq (& mapping-> tree_lock);
        __remove_from_page_cache (page);
        spin_unlock_irq (& mapping-> tree_lock);
        mem_cgroup_uncharge_cache_page (page);
 
        if (freepage)
                freepage (page);
}

These two functions are generic, block device and file inode can be called, as the update is a block device (buffers) or file (cached), depending on the call parameters variable mapping: If the corresponding mapping file inode, natural It will not affect the "buffers"; if the mapping corresponds to the block device, then the corresponding statistics will be reflected in the "buffers" in. Here we take a look at where the kernel will pass in a block device mapping.

Search the kernel source code found parameters ext4_readdir function call is passed page_cache_sync_readahead sb-> s_bdev-> bd_inode-> i_mapping, which s_bdev is a block device, that read directories (ext4_readdir) may increase when "buffers" values :

staticintext4_readdir (structfile * filp,
                        void * dirent, filldir_t filldir)
{
 
...
        structsuper_block * sb = inode-> i_sb;
...
                        if (! ra_has_index (& filp-> f_ra, index))
                                page_cache_sync_readahead (
                                        sb-> s_bdev-> bd_inode-> i_mapping,
                                        & Filp-> f_ra, filp,
                                        index, 1);
...
}

Continue pondering the above code, sb represents SuperBlock, belonging to the file system metadata (metadata), and suddenly everything suddenly: because metadata is not part of the file, there is no corresponding inode, therefore, cached page metadata involved in the operation can only use block device mapping, counted into the statistics of buffers.

Make a fork: ext4_readdir call () in page_cache_sync_readahead () apparently during the pre-read (read-ahead), read-ahead Why not use ordinary file inode of mapping, but the use of the underlying block device do? From the description recorded in the patch, this is a stopgap measure, look here, so do not get to the bottom.

By analogy, if the file contains indirect blocks (indirect blocks), because indirect block belonging to metadata, so mapping is walking a block device. View the source code, is really the case:

ext4_get_blocks
-> Ext4_ind_get_blocks
    -> Ext4_get_branch
        -> Sb_getblk
 
staticinline structbuffer_head *
sb_getblk (structsuper_block * sb, sector_t block)
{
        return__getblk (sb-> s_bdev, block, sb-> s_blocksize);
}

In this way, we will know, "buffers" is a block device (block device) occupied by cached pages, divided into two situations:

For block devices directly read and write operations;
File system metadata (metadata), such as SuperBlock.
verification:
Now let's do a test, to test the above conclusion. Now read the directory EXT4 file system will be used to "buffers", we use the find command scans the file system, observe the "buffers" to increase the case:

# Free
            total used free shared buffers cached
Mem: 3848656 2889508 959148 5316 263896 2023340
- / + Buffers / cache: 602272 3246384
Swap: 2031612 0 2031612
 
# Find / -name abc.def
 
# Free
            total used free shared buffers cached
Mem: 3848656 2984052 864604 5320 319612 2023348
- / + Buffers / cache: 641092 3207564
Swap: 2031612 0 2031612

Re-test directly read block device, observe the "buffers" to increase the phenomenon:

# Free
            total used free shared buffers cached
Mem: 3848656 3006944 841712 5316 331020 2028648
- / + Buffers / cache: 647276 3201380
Swap: 2031612 0 2031612
 
# Dd if = / dev / sda1 of = / dev / null count = 2000
2000 + 0records in
2000 + 0records out
1024000bytes (1.0MB) copied, 0.026413s, 38.8MB / s
 
# Free
            total used free shared buffers cached
Mem: 3848656 3007704 840952 5316 331872 2028692
- / + Buffers / cache: 647140 3201516
Swap: 2031612 0 2031612

in conclusion:
free command displays the "buffers", a block device (block device) occupied by cached pages, including direct block device to read and write, as well as file system metadata (metadata) as SuperBlock used cached pages;
And "cached" indicates a regular file occupied the cache page.
     
         
         
         
  More:      
 
- Installation Mate Desktop in FreeBSD 10.1 (Linux)
- ORA-4031 error Solution (Database)
- Node.js development environment deployment (Server)
- To install and use the Doxygen under Linux (Linux)
- ActiveMQ configuration Getting Started Tutorial (Server)
- CentOS 7.0 Enable iptables firewall (Linux)
- Python several standard types of built-in functions (Programming)
- Protect your files, modify the Linux value Umask (Linux)
- CentOS Nginx achieve 3 virtual machine load balancing (Server)
- How to cool down your Ubuntu system (Linux)
- How to override the plain text files and directories soft connection in linux (Linux)
- Hadoop2.6.3 build clusters and the development of MapReduce WIN7 by Eclipse on Linux demo (Server)
- xCAT install and update software (Linux)
- Use Markdown editor for document work under Linux (Linux)
- Analysis of potential problems through custom Orabbix monitoring Oracle (Database)
- Use calcurse schedule appointments and to-do in the Linux terminal (Linux)
- Linux systems use logwatch log file monitoring (Linux)
- Role Object of registerNatives () method (Programming)
- Java MVC CRUD examples (Programming)
- Binary tree traversal recursive and non-recursive (cyclic) traversal achieve (Programming)
     
           
     
  CopyRight 2002-2022 newfreesoft.com, All Rights Reserved.