Shulou(Shulou.com)06/01 Report--

This article mainly introduces "the introduction of basic memory management knowledge of Linux system". In daily operation, I believe that many people have doubts about the introduction of basic memory management knowledge of Linux system. The editor consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful to answer the doubts of "introduction to basic memory management knowledge of Linux system". Next, please follow the editor to study!

Memory is one of the most important resources managed by the Linux kernel. The memory management system is the most important part of the operating system because the physical memory of the system is always less than the amount of memory the system needs. Virtual memory is the strategy used to overcome this contradiction. The virtual memory of the system makes the system appear to have more memory than the actual memory by sharing memory between processes. Linux supports virtual memory, which uses disk as an extension of RAM to effectively expand the available memory accordingly. The core saves blocks of memory that are not currently in use to the hard disk, freeing up memory for other purposes. When the original content is to be used again, read it back to memory.

I. memory usage monitoring

(1) Real-time monitoring of memory usage

Use the "Free" command on the command line to monitor memory usage

The code is as follows:

# free

Total used free shared buffers cached

Mem: 256024 192284 63740 0 10676 101004

-/ + buffers/cache: 80604 175420

Swap: 522072 0 522072

A 256-megabyte RAM and 512-megabyte swap space system is shown above. The third line of output (Mem:) shows the physical memory. The total column does not show the physical memory used by the core (usually about 1MB). The used column shows the total amount of memory used (the second row is not buffered). The free column shows all unused memory. The Shared column shows the total amount of memory shared by multiple processes. The Buffers column shows the current size of the disk cache. The fifth line (Swap:) shows information similar to the above for the swap space. If this behavior is all zero, then no swap space is used. By default, the free command shows memory usage in kilobytes (that is, 1024 bytes). You can use the-h parameter to display memory usage in bytes, or you can use the-m parameter to display memory usage in megabytes. You can also use the command with the-s parameter to continuously monitor memory usage:

# free-b-S2

This command will continuously report memory usage in the terminal window, updated every 2 seconds.

(2) combine watch and free commands to monitor memory usage in real time:

The code is as follows:

# watch-n 2-d free

Every 2.0s: free Fri Jul 6 06:06:12 2007

Total used free shared buffers cached

Mem: 233356 218616 14740 0 5560 64784

-/ + buffers/cache: 148272 85084

Swap: 622584 6656 615928

The watch command executes free every two seconds, clears the screen and displays data in the same location before execution. Because the watch command does not scroll the screen, it is suitable for monitoring memory usage for a long time. You can use the-n option to control the frequency of execution, or you can use the-d option to have the command show a different place each time. The Watch command is executed until you press [Ctrl]-[C].

II. The concept of virtual memory

(1) Linux virtual memory implementation mechanism

The implementation of Linux virtual memory needs the support of six mechanisms: address mapping mechanism, memory allocation recovery mechanism, cache and refresh mechanism, request page mechanism, exchange mechanism, memory sharing mechanism.

First of all, the memory management program maps the logical address of the user program to the physical address through the mapping mechanism, and when the user program is running, if it is found that the virtual address to be used in the program does not have the corresponding physical memory, the request page request is issued. If there is free memory to allocate, request the allocation of memory (hence memory allocation and recycling) and record the physical pages in use in the cache (using the caching mechanism). If there is not enough memory to allocate, the swap mechanism is invoked to free up some memory. In addition, the physical page should be found through TLB (translation backup memory) in the address mapping; the exchange cache should also be used in the exchange mechanism, and the page table should be modified to map the file address after swapping the physical page content into the exchange file.

(2) Virtual memory capacity setting

Someone may tell you that virtual memory should be allocated twice as much as physical memory, but this is not a fixed rule. If your physical save is relatively small, you can set it this way. If you have 1 gigabyte of physical memory or more, you can shrink the virtual memory. Linux uses a lot of memory for Cache, but it is recycled when resources are tight. You can rest assured as long as you see that the swap is 0 or very small, because storage is the biggest waste.

Third, use the vmstat command to monitor the use of virtual memory

Vmstat is the abbreviation of Virtual Meomory Statistics (Virtual memory Statistics), which can monitor the virtual memory, processes, and CPU activities of the operating system. It is the statistics of the overall situation of the system, the deficiency is that it is unable to carry out in-depth analysis of a process. It is usually tested with the vmstat 5 5 command, which means 5 samples are taken in 5 seconds. You will get a summary of the data that reflects the real system.

The code is as follows:

# vmstat 5 5

Procs-memory--swap---io-----system---cpu

R b swpd free buff cache si so bi bo in cs us sy id wa

10 62792 3460 9116 88092 6 30 189 89 1061 569 17 28 54 2

00 62792 3400 9124 88092 00 0 14 884 434 4 14 81 0

00 62792 3400 9132 88092 00 0 14 877 424 4 15 81 0

1 0 62792 3400 9140 88092 00 0 14 868 418 6 20 74 0

1 0 62792 3400 9148 88092 00 0 15 847 400 9 25 67 0

The vmstat command output is divided into six parts:

(1) process procs:

R: the number of processes waiting in the run queue.

B: the number of processes waiting for io.

(2) memory memoy:

Swpd: currently available swap memory (in KB).

Free: free memory (in KB).

Buff: the number of memory buffered out (in KB).

Cache: the amount of memory used for caching (in KB).

(3) swap exchange page

Si: the number of swapped pages swapped from disk to memory, in KB/ seconds.

So: the number of swapped pages swapped from memory to disk, in KB/ seconds.

(4) io block equipment:

Bi: the number of blocks sent to the block device, in blocks per second.

Bo: the number of blocks received from the block device, in blocks per second.

(5) system system:

In: number of interrupts per second, including clock interrupts.

Cs: number of environment (context) switches per second.

(6) cpu CPU:

Cs: the time spent by the user process. Expressed as a percentage.

Sy: the time used by the system process. Expressed as a percentage.

Id: idle time of the CPU. Expressed as a percentage.

If r is often greater than 4 and id is often less than 40, the CPU is heavily loaded. If bi,bo is not equal to 0 for a long time, the physical memory capacity is too small.

Fourth, the memory leak of Linux server and the method of reclaiming memory.

1. Definition of memory leak:

Generally speaking, memory leaks refer to heap memory leaks. Heap memory refers to the arbitrary size allocated by the program from the heap (the size of the memory block can be determined during the run time of the program), and the freed memory must be displayed after use. Applications usually use functions such as malloc,realloc,new to allocate a piece of memory from the heap. After use, the program must be responsible for calling free or delete to release the block of memory, otherwise, this piece of memory can not be used again, we will say that this piece of memory is leaked.

2. The harm of memory leak

From the point of view of the user using the program, the memory leak itself will not cause any harm, as the general user, can not feel the existence of the memory leak at all. What is really harmful is the accumulation of memory leaks, which will eventually consume all the memory of the system. From this point of view, one-time memory leaks are harmless because they do not accumulate, while implicit memory leaks are very harmful because they are more difficult to detect than recurrent and sporadic memory leaks. Programs with memory leaks will not only occupy more memory, but also lead to a sharp decline in program performance. For the server, if this happens, even if the system does not crash, it will seriously affect usage.

3. Memory leak detection and recovery

Problems such as memory overflows may be encountered when writing complex programs with many pointers. Under Linux or unix, C and C++ languages are the most used tools. However, our C++ program lacks the corresponding means to detect memory information, so we can only use the top instruction to observe the total dynamic memory of the process. And when the program exits, we can't get any memory leak information.

Use the kill command

Using the Linux command to reclaim memory, we can use the Ps and Kill commands to detect memory usage and reclaim it. Use the command "Ps" when using superuser privileges, which lists the names of all running programs and the corresponding process number (PID). The Kill command works by sending a system operation signal and process number (PID) of the program to the kernel of the Linux operating system.

Application examples:

To recycle memory efficiently, you can use the command ps parameter v:

The code is as follows:

[root@www ~] # ps v

PID TTY STAT TIME MAJFL TRS DRS RSS MEM COMMAND

2542 tty1 Ss+ 0:00 0 8 1627 428 0.1 / sbin/mingetty tty1

2543 tty2 Ss+ 0:00 0 8 1631 428 0.1 / sbin/mingetty tty2

2547 tty3 Ss+ 0:00 0 8 1631 432 0.1 / sbin/mingetty tty3

2548 tty4 Ss+ 0:00 0 8 1627 428 0.1 / sbin/mingetty tty4

2574 tty5 Ss+ 0:00 0 8 1631 432 0.1 / sbin/mingetty tty5

2587 tty6 Ss+ 0:00 0 8 1627 424 0.1 / sbin/mingetty tty6

2657 tty7 Ss+ 1:18 12 1710 29981 7040 1710 / usr/bin/Xorg: 0-br-a

2670 pts/2 Ss 0:01 2 682 6213 1496 1496-bash

3008 pts/4 Ss 0:00 2 682 6221 1472 0.6 / bin/bash

3029 pts/4 S+ 0:00 2 32 1783 548 0.2 ping 192.168.1.12

3030 pts/2 R + 0:00 2 73 5134 768 0.3 ps v

Then if you want to reclaim the memory of the Ping command, use the command:

The code is as follows:

# Kill-9 3029

Use tool softwar

Memprof is a very attractive and easy-to-use software created by Owen Talyor of Red Hat. This tool is the Boehm-Demers-Weiser garbage collector for the front end of GNOME. This tool can be executed directly, and it works without any changes to the source code. As the program executes, the tool graphically displays memory usage.

At this point, the study of "introduction to the basic memory management knowledge of Linux system" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.