The free command displays the idle, used physical memory and swap memory in the Linux system, and the buffer used by the kernel. In the Linux system Monitoring tool, the free command is one of the most frequently used commands.
1. Command format:
free [parameters]
2. Command function:
The free command displays the system's use and idle memory, including physical memory, interactive area memory (swap), and kernel buffer memory. Shared memory will be ignored
3. Command parameters:
-B Displays memory usage in byte.
-K displays memory usage in kilobytes.
-m displays memory usage in MB.
-G displays memory usage in GB.
-O does not display buffer throttling columns.
-s< interval seconds > Continuous observation of memory usage.
-T displays the memory sum column.
-V Displays version information.
4. Use instance:
Example 1: Displaying memory usage
command:
Free
Free-g
Free-m
Output:
[Root@sf1150 service]# Free
Total used free shared buffers Cached
mem:32940112 30841684 2098428 0 4545340 11363424
-/+ buffers/cache:14932920 18007192
swap:32764556 1944984 30819572
[Root@sf1150 service]# Free-g
Total used free shared buffers Cached
Mem:31 29 2 0 4 10
-/+ buffers/cache:14 17
Swap:31 1 29
[Root@sf1150 service]# Free-m
Total used free shared buffers Cached
mem:32168 30119 2048 0 4438 11097
-/+ buffers/cache:14583 17584
swap:31996 1899 30097
Description:
The following is an explanation of these values:
Total: The amount of physical memory.
Used: How big it has been used.
Free: How many are available.
Shared: The total amount of memory shared by multiple processes.
Buffers/cached: The size of the disk cache.
(-buffers/cache) used memory: Refers to the first part of the Mem line in the used-buffers-cached
(+buffers/cache) Free memory: Refers to the first part of the Mem line in the Free + buffers + Cached
Visible-buffers/cache reflects the memory that is actually eaten by the program, and +buffers/cache reflects the total amount of memory that can be misappropriated.
The Forth line is swap partition swap, which is what we usually call virtual memory.
Difference: The difference between the used/free of the second line (MEM) and the used/free of the third row (-/+ Buffers/cache). The difference between the two is that the first line is from the OS point of view, because for os,buffers/cached is used, so his available memory is 2098428KB, the used memory is 30841684KB, which includes, the kernel (OS) uses + Application (X, oracle,etc) used by +buffers+cached.
The third line refers to the application from the point of view of the application, buffers/cached is equal to available, because buffer/cached is to improve the performance of file read, when the application needs to use memory, the buffer/cached will be quickly recycled.
So from an application perspective, the available memory = System Free memory+buffers+cached.
The available memory, such as the native case, is:
18007156=2098428kb+4545340kb+11363424kb
then explain when memory will be exchanged and by what side.
When the available memory is less than the rated value, the meeting is exchanged. How to look at the rating:
Command:
Cat/proc/meminfo
Output:
[Root@sf1150 service]# Cat/proc/meminfo
memtotal:32940112 KB
memfree:2096700 KB
buffers:4545340 KB
cached:11364056 KB
swapcached:1896080 KB
active:22739776 KB
inactive:7427836 KB
hightotal:0 KB
highfree:0 KB
lowtotal:32940112 KB
lowfree:2096700 KB
swaptotal:32764556 KB
swapfree:30819572 KB
dirty:164 KB
writeback:0 KB
anonpages:14153592 KB
mapped:20748 KB
slab:590232 KB
pagetables:34200 KB
nfs_unstable:0 KB
bounce:0 KB
commitlimit:49234612 KB
committed_as:23247544 KB
vmalloctotal:34359738367 KB
vmallocused:278840 KB
vmallocchunk:34359459371 KB
hugepages_total:0hugepages_free:0hugepages_rsvd:0hugepagesize:2048 KB
Swapping will reduce the number of physical pages used in the system in three ways:
1. Reduce buffer and page cache size,
2. Swap the System V type of memory page out,
3. Swap or discard the page. (The memory page that application occupies, that is, insufficient physical memory).
In fact, a small amount of swap use does not affect system performance.
that buffers and cached are all caches, what's the difference between them.
In order to improve disk access efficiency, Linux has done a number of careful design, in addition to the Dentry cache (for VFS, speed file path name to the Inode conversion), but also took two main Cache: Buffer cache and Page cache. The former is read and write to disk block, the latter is read and write to the file inode. These cache effectively shorten the time of the I/O system call (such as read,write,getdents).
The operation of a disk has a logical level (file system) and a physical level (disk block), both of which cache logical and physical level data separately.
Page cache is actually for the file system, the cache of files, and the data at the file level is cached to page cache. The logical layer of the file needs to be mapped to the actual physical disk, which is done by the file system. When page cache data needs to be refreshed, the data in page cache is given to the buffer cache, because buffer caches are cached disk blocks. But this processing in the 2.6 version of the kernel after the change is very simple, there is no real sense of the cache operation.
Buffer cache is for disk block caching, that is, in the case of no file system, directly to the operation of the disk data will be cached in buffer cache, for example, file system metadata will be cached in buffer cache.
Simply put, page cache is used to cache file data, and buffer caches are used to cache disk data. In the case of a file system, the file operation, then the data will be cached to page cache, if the direct use of DD and other tools to read and write the disk, then the data will be cached to buffer cache.
So we look at Linux, as long as the swap space without swap, there is no need to worry about their own memory too little. If you use a lot of swap, you might want to consider adding physical memory. This is also the standard for Linux to see if memory is enough.
If it is an application server, usually only look at the second line, +buffers/cache, that is, for the application free memory is too little, it is also to consider the optimizer or add memory.
Instance 2: Displays memory usage information as a sum
command:
Free-t
Output:
[Root@sf1150 service]# Free-t
Total used free shared buffers Cached
mem:32940112 30845024 2095088 0 4545340 11364324
-/+ buffers/cache:14935360 18004752swap:32764556 1944984 30819572total:65704668 32790008 oot@sf1150 service]#
Description:
Example 3: Periodic query memory usage information
command:
Free-s 10
Output:
[root@sf1150 service]# free-s 10
Total used free shared buffers Cached
mem:32940112 30844528 2095584 0 4545340 11364380
-/+ buffers/cache:14934808 18005304swap:32764556 1944984 30819572
Total used free shared buffers Cached
mem:32940112 30843932 2096180 0 4545340 11364388
-/+ buffers/cache:14934204 18005908swap:32764556 1944984 30819572
Description:
Execute one command per 10s