A brief discussion on Linux virtual memory

origin

Virtual Memory

Virtual memory is undoubtedly one of the most important concepts in operating systems. I think it is mainly due to the important "strategic position" of memory. The CPU is too fast, but has small capacity and limited functionality. Other I/O hardware supports a variety of fancy functions, but they are too slow compared to the CPU. So a lubricant is needed between them to act as a buffer, and this is where memory comes into play.

The above picture is the simplest and most intuitive explanation of virtual memory.

The operating system has a piece of physical memory (the middle part), and two processes (actually there will be more) P1 and P2. The operating system secretly tells P1 and P2 respectively that my entire memory is yours, you can use it as you like, as much as you want. But in fact, the operating system only painted a big picture for them, saying that all the memory is given to P1 and P2, but in fact it only gave them a serial number. Only when P1 and P2 actually start to use the memory, the system starts to move and piece together the blocks for the process to use. P2 thinks it is using memory A, but in fact it has been quietly redirected to the real memory B by the system. Even when P1 and P2 share memory C, they don't even know it.

The operating system's method of deceiving processes is virtual memory. For processes such as P1 and P2, they all think that they occupy the entire memory, but they do not know and do not need to care which address of the physical memory they use.

Paging and Page Tables

Virtual memory is a concept in the operating system. For the operating system, virtual memory is a series of comparison tables. When P1 obtains data in memory A, it should go to address A in the physical memory, and when looking for data in memory B, it should go to address C in the physical memory.

We know that the basic unit in the system is Byte. If each Byte of virtual memory is mapped to the address of physical memory, each entry requires at least 8 bytes (32-bit virtual address -> 32-bit physical address). In the case of 4G memory, 32GB of space is required to store the comparison table. Then this table is so large that the real physical address cannot be contained. Therefore, the operating system introduces the concept of page.

When the system starts, the operating system divides the entire physical memory into pages in units of 4K. When allocating memory afterwards, pages are used as units. Therefore, the mapping table of virtual memory pages corresponding to physical memory pages is greatly reduced. For 4G memory, only 8M mapping table is needed. The mapping relationship of virtual memory not used by some processes does not need to be saved. In addition, Linux has designed a multi-level page table for large memory, which can further reduce memory consumption. The mapping table from the operating system's virtual memory to physical memory is called a page table.

Memory addressing and allocation

We know that through the virtual memory mechanism, each process thinks that it occupies all the memory. When the process accesses the memory, the operating system will convert the virtual memory address provided by the process into a physical address, and then get the data from the corresponding physical address. There is a kind of hardware in the CPU, the memory management unit MMU (Memory Management Unit) is specifically used to translate virtual memory addresses. The CPU also sets a cache strategy for page table addressing. Due to the locality of the program, its cache hit rate can reach 98%.

The above situation is that there is a mapping from virtual address to physical address in the page table. If the physical address accessed by the process has not been allocated, the system will generate a page fault interrupt. When the interrupt is processed, the system switches to kernel state to allocate a physical address for the process virtual address.

Function

Virtual memory not only solves the problem of memory access conflicts among multiple processes through memory address translation, but also brings more benefits.

Process memory management

It helps the process to manage memory, mainly in:

• Memory integrity: Due to the "deception" of virtual memory to the process, each process believes that the memory it obtains is a continuous address. When we write applications, we don't need to consider the allocation of large blocks of addresses. We can always assume that the system has enough large blocks of memory.
• Security: Since every time a process accesses memory, it must address it through the page table, the operating system can implement memory permission control by adding various access permission identification bits to each item in the page table.

Data Sharing

Virtual memory makes it easier to share memory and data.

When a process loads a system library, it always allocates a block of memory first and loads the library file from the disk into this memory. When using physical memory directly, since the physical memory address is unique, even if the system finds that the same library is loaded twice in the system, the loading memory specified by each process is different, the system can do nothing.

When using virtual memory, the system only needs to point the virtual memory address of the process to the physical memory address where the library file is located. As shown in the figure above, the B address of processes P1 and P2 both point to physical address C.

It is also very simple to use shared memory by using virtual memory. The system only needs to point the virtual memory address of each process to the shared memory address allocated by the system.

SWAP

Virtual memory allows processes to "expand" memory.

We mentioned earlier that virtual memory allocates physical memory to the process through page fault interrupts. Memory is always limited. What if all physical memory is occupied?

Linux proposes the concept of SWAP. SWAP partitions can be used in Linux. When physical memory is allocated but available memory is insufficient, temporarily unused memory data will be placed on the disk first so that the process in need can use it first. When the process needs to use this data again, the data will be loaded into the memory. Through this "swap" technology, Linux can allow the process to use more memory.

Frequently asked questions

I also had a lot of questions when learning about virtual memory.

32-bit and 64-bit

The most common problem is 32-bit and 64-bit.

The CPU accesses memory through the physical bus, so the range of the access address is limited by the number of machine buses. On a 32-bit machine, there are 32 buses, and each bus has high and low potentials representing bit 1 and 0 respectively. The maximum accessible address is 2^32bit = 4GB. Therefore, it is invalid to insert more than 4G of memory on a 32-bit machine, and the CPU cannot access more than 4G of memory.

However, 64-bit machines do not have a 64-bit bus, and their maximum memory is limited by the operating system. Linux currently supports a maximum of 256G of memory.

According to the concept of virtual memory, it is not impossible to run 64-bit software on a 32-bit system. However, due to the structural design of the virtual memory address of the system, the 64-bit virtual address cannot be used in a 32-bit system.

Directly operate physical memory

The operating system uses virtual memory. What should we do if we want to operate the memory directly?

Linux maps each device to files in the /dev/ directory. We can directly operate the hardware through these device files, and memory is no exception. In Linux, memory settings are mapped to /dev/mem, and the root user can directly operate the memory by reading and writing this file.

The JVM process occupies too much virtual memory

When using TOP to view system performance, we will find that in the VIRT column, the Java process will occupy a large amount of virtual memory.

The reason for this problem is that Java uses Glibc's Arena memory pool to allocate a large amount of virtual memory and does not use it. In addition, the files read by Java will also be mapped as virtual memory. Under the default configuration of the virtual machine, each Java thread stack will occupy 1M of virtual memory. You can check out why multi-threaded programs consume so much virtual memory under Linux.

The actual physical memory occupied can be seen in the RES (resident) column. The value of this column is the size that is actually mapped to the physical memory.

Common management commands

We can also manage Linux's virtual memory ourselves.

Check system memory status

There are many ways to view the system memory status. Commands such as free and vmstat can output the current system memory status. It should be noted that the available memory is not just the free column. Due to the lazy nature of the operating system, a large number of buffers/caches will not be cleaned up immediately after the process is no longer in use. If the process that used them before runs again, they can continue to be used and can be used when necessary.

In addition, you can use cat /proc/meminfo to view detailed information about system memory usage, including the status of dirty pages. For more details, see: /PROC/MEMINFO mystery.

pmap

If you want to view the virtual memory distribution of a certain process separately, you can use the pmap pid command, which will list the occupancy of each virtual memory segment from low address to high address.

You can add the -XX parameter to output more detailed information.

Modify memory configuration

We can also modify the Linux system configuration, use sysctl vm [-options] CONFIG or directly read and write files in the /proc/sys/vm/ directory to view and modify the configuration.

SWAP Operation

The SWAP feature of virtual memory is not always beneficial. Allowing the process to constantly exchange large amounts of data between memory and disk will greatly occupy the CPU and reduce system efficiency, so sometimes we do not want to use swap.

We can modify vm.swappiness=0 to set the memory to use swap as little as possible, or simply use the swapoff command to disable SWAP.

summary

The concept of virtual memory is very easy to understand, but it will lead to a series of very complex knowledge. This article only talks about some basic principles and skips many details, such as the use of segment registers in virtual memory addressing, the use of virtual memory in the operating system to enhance cache and buffer applications, etc., which will be discussed separately when there is a chance.

The above is a brief discussion of the details of Linux virtual memory. For more information about Linux virtual memory, please pay attention to other related articles on 123WORDPRESS.COM!