This is the 20th day of my participation in the November Gwen Challenge. Check out the details: The last Gwen Challenge 2021

Introduction of the command

Vmstat is short for Virtual Meomory Statistics. It monitors the Virtual memory, process, and CPU activities of an OPERATING system (OS). He is to the overall situation of the system statistics, the deficiency of a process can not be in-depth analysis.

The statistics provided by the vmstat command are mainly from the /proc/meminfo, /proc/stat, and /proc/*/stat files maintained by the system kernel.

The command format

vmstat [-a] [-n] [-S unit] [delay [ count]] vmstat [-s] [-n] [-S unit] vmstat [-m] [-n] [delay [ count]] vmstat [-d] [-n] [delay [count]] vmstat [-p disk partition] [-n] [delay [count]] vmstat [-f] vmstat [-v] Commercial reproduced please contact the author for authorization, non-commercial please keep the original link: https://www.yiibai.com/linux/vmstat.htmlCopy the code

The command parameter

VM mode output field description

Procs (Process status information)

Memory (Memory usage)

Swap memory disk Swap

IO

System

CPU (percentage of total CPU time allocated)

Disk mode Output field description

Reads

Writes

IO

Disk partition mode Output field description

Output fields in SLAB mode

Physical memory and virtual memory

This section comes from the vmstat command

We know that reading and writing data directly from physical memory is much faster than reading and writing data from hard disk. Therefore, we want all data to be read and written in memory, and memory is limited. This introduces the concept of physical memory and virtual memory. Physical memory is the amount of memory provided by the system hardware, which is the real memory. Relative to physical memory, there is a concept of virtual memory under Linux. Virtual memory is a strategy proposed to meet the shortage of physical memory. The disk Space used for virtual memory is called Swap Space. As an extension of the physical memory, Linux can be in physical memory, virtual memory use the swap partition, more detailed said, is the kernel will temporarily unused memory block write information exchange of space, so that physical memory is released, the memory can be used for other purposes, when the content of the need to use the original, This information is read back into physical memory from the swap space. The memory management of Linux adopts the paging access mechanism. In order to make full use of the physical memory, the kernel will automatically swap the infrequently used data blocks in the physical memory to the virtual memory at the appropriate time, and reserve the frequently used information to the physical memory.

To understand the Linux memory mechanism, you need to know the following aspects:

• First, Linux will swap pages from time to time to keep as much free physical memory as possible, even if there is no need for memory, Linux will swap pages of memory that are not used for a while. This avoids the time required to wait for an exchange.
• Not all pages are swapped to virtual memory when not in use. The Linux kernel swaps only infrequently used page files to virtual memory according to the “most recently used” algorithm. Sometimes we see this phenomenon: There’s a lot more Linux physical memory, but swap space is also used a lot. In fact, this is not surprising, for example, a process takes up a lot of memory, it requires a lot of memory resources, at this time there will be some not commonly used page file be traded to the virtual memory, but then the end of this process takes up a lot of memory resources and release a lot of memory, just be swapped out the page file does not automatically switch into physical memory, Unless this is necessary, the system will have a lot of free physical memory and swap space will be used at the same time, and this phenomenon will occur. Don’t worry about that, just know what it is.
• Finally, swap space page in use will first be traded to physical memory, if there is not enough physical memory to accommodate these pages, they will be swapped out immediately, so, the virtual memory may not be enough space to store these exchange page, eventually lead to Linux problems such as abnormal dead, service, Linux can recover itself over a period of time, but the restored system is essentially unusable. Therefore, it is very important to plan and design Linux memory usage properly.

Principle of Virtual Memory

Every process running on the system needs to use memory, but not every process needs to use the memory space allocated by the system all the time. When the memory required to run the system exceeds the actual physical memory, the kernel frees some or all of the unused physical memory occupied by some processes, stores this data on disk until the next time the process is called, and makes the freed memory available to other processes that need it.

In Linux memory management, the above memory scheduling is done mainly through “Paging” and “exchanging Considerations”. Paging algorithm is to move the recently infrequently used pages in memory to disk, leaving active pages in memory for the process to use. Swap is a technique that swaps entire processes, not just parts of pages, onto disk. Paging (Page) The process of writing to disk is called page-out, and the process of paging (Page) from disk back to memory is called page-in. A Page Fault occurs when the kernel needs a Page that is not in physical memory (because it has been page-out).

When the kernel detects that runnable memory is running low, it frees some of the physical memory through page-out. Page-out doesn’t happen very often, but if page-out happens frequently and repeatedly, until the kernel manages paging for longer than the program can run, system performance deteriorates dramatically. The system is already running very slowly or in a suspended state, also known as thrashing.

Reference documentation

• The vmstat command
• “Linux Common Commands concise Manual” — Xing Guoqing edited