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

This article mainly explains "how to limit the occupancy rate of CPU in the Linux system". The explanation in the article is simple and clear and easy to learn and understand. Please follow the editor's train of thought to study and learn "how to limit the occupancy rate of CPU in the Linux system".

The Linux kernel is a great circus performer, carefully juggling between processes and system resources, and keeping the system running. At the same time, the kernel is fair: it allocates resources fairly to processes.

But what if you need to give priority to an important process? Or, how do you lower the priority of a process? Or, how do you limit the resources used by a set of processes?

The answer is that it is up to the user to specify the priority of the process for the kernel

Most processes start with the same priority, so the Linux kernel schedules fairly. If you want a CPU-intensive process to run at a lower priority, you have to configure the scheduler in advance.

Here are three ways to control the running time of a process:

Use the nice command to manually lower the priority of the task.

Use the cpulimit command to pause the process continuously to control that the processing power consumed by the process does not exceed a certain limit.

Using linux's built-in control groups (control group) function, it provides a mechanism to limit the consumption of process resources.

Let's take a look at how these three tools work and their respective advantages and disadvantages.

Simulate high cpu occupancy

Before analyzing these three technologies, we need to install a tool to simulate scenarios with high CPU occupancy. We will use CentOS as the test system and use the prime generator in Mathomatic toolkit to simulate the CPU load.

Unfortunately, there is no precompiled version of this tool on CentOS, so you have to install it from source. First download the source package from the link http://mathomatic.orgserve.de/mathomatic-16.0.5.tar.bz2 and extract it. Then go to the mathomatic-16.0.5/primes folder and run make and sudo make install to compile and install. This installs the matho-primes program into the / usr/local/bin directory.

Next, run from the command line:

The code is as follows:

/ usr/local/bin/matho-primes 0 9999999999 > / dev/null &

After the program runs, it will output prime numbers from 0 to 9999999999. Since we don't need these outputs, just redirect the output to / dev/null.

Now, using the top command, you can see that the matho-primes process has drained all your cpu resources.

All right, next (press Q) to exit top and kill the matho-primes process (use the fg command to switch the process to the foreground, and then press CTRL+C)

Nice command

Here's how to use the nice command, which modifies the priority of the process so that the process runs less frequently. This feature is particularly useful when running cpu-intensive background processes or batch jobs. The range of nice values is [- 20 ~ 19], with-20 being the highest priority and 19 being the lowest priority. The default nice value for the Linux process is 0. Use the nice command (without any parameters) to set the nice value of the process to 10. In this way, the scheduler treats this process as a lower priority process, thus reducing the allocation of cpu resources.

Let's take a look at an example where we run two matho-primes processes at the same time, one using the nice command to start the run, and the other to start running normally:

The code is as follows:

Nice matho-primes 0 9999999999 > / dev/null &

Matho-primes 0 9999999999 > / dev/null &

Run the top command again.

See, normally running processes (nice value 0) get more cpu run time, whereas processes running with the nice command take less cpu time (nice value is 10).

In practice, if you are running a CPU-intensive program, it is best to start it with the nice command to ensure that other processes are given a higher priority. In other words, even if your server or desktop is overloaded, it can respond quickly.

Nice also has an associated command called renice, which adjusts the nice value of the process at run time. When using the renice command, first find out the PID of the process. Here is an example:

The code is as follows:

Renice + 10 1234

Of which 1234 is the PID of the process.

After testing the nice and renice commands, remember to kill all matho-primes processes.

Cpulimit command

Next, let's introduce the use of the cpulimit command. The cpulimit command works by setting a cpu occupancy threshold for the process, monitoring whether the process exceeds this threshold in real time, and suspending the process for a period of time if it exceeds it. Cpulimit uses SIGSTOP and SIGCONT signals to control the process. It does not modify the nice value of the process, but makes dynamic adjustments by monitoring the cpu utilization of the process.

The advantage of cpulimit is that it can control the upper limit of the cpu utilization of the process. However, there is a disadvantage compared with nice, that is, even if the cpu is idle, the process cannot fully use the entire cpu resource.

On CentOS, you can install it in the following ways:

The code is as follows:

Wget-O cpulimit.zip https://github.com/opsengine/cpulimit/archive/master.zip

Unzip cpulimit.zip

Cd cpulimit-master

Make

Sudo cp src/cpulimit / usr/bin

The above command line downloads the source code locally from GitHub, then decompresses, compiles, and installs it to the / usr/bin directory.

Cpulimit is used in a similar manner to the nice command, but requires the user to explicitly define the upper limit of cpu usage for the process using the-l option. Examples are as follows:

The code is as follows:

Cpulimit-l 50 matho-primes 0 9999999999 > / dev/null &

As can be seen from the above example, matho-primes uses only 50% of the cpu resources, and the rest of the cpu time is in idle.

Cpulimit can also dynamically restrict the process at run time, using the-p option to specify the PID of the process. Here is an example:

The code is as follows:

Cpulimit-l 50-p 1234

Of which 1234 is the PID of the process.

Cgroups command set

Finally, the usage of the most powerful control group (cgroups) is introduced. Cgroups is a mechanism provided by the Linux kernel that allows you to specify the resource allocation for a group of processes. Specifically, with cgroups, users can limit the cpu utilization of a set of processes, system memory consumption, network bandwidth, and the combination of these resources.

The advantage over nice and cpulimit,cgroups is that it can control a group of processes, unlike the former, which can only control a single process. At the same time, nice and cpulimit can only limit cpu usage, while cgroups can restrict the use of other process resources.

The resource consumption of the whole subsystem can be controlled by making good use of cgroups. Take, for example, CoreOS, the simplest Linux distribution designed for large-scale server deployment, whose upgrade process is managed by cgroups. In this way, the system will not affect the performance of the system when downloading and installing the upgraded version.

To demonstrate, we will create two control groups (cgroups) and assign different cpu resources to them. The two control groups are named "cpulimited" and "lesscpulimited" respectively.

Use the cgcreate command to create a control group, as follows:

The code is as follows:

Sudo cgcreate-g cpu:/cpulimited

Sudo cgcreate-g cpu:/lesscpulimited

The "- g cpu" option is used to set the upper limit of cpu usage. In addition to cpu, cgroups also provides cpuset, memory, blkio and other controllers. The difference between cpuset controller and cpu controller is that cpu controller can only limit the utilization of one cpu core, while cpuset can control multiple cpu cores.

The cpu.shares attribute in the cpu controller is used to control cpu usage. Its default value is 1024, and we set the cpu.shares of the lesscpulimited control group to 1024 (the default) and cpulimited to 512, and the kernel allocates resources to the two control groups at 2:1 after configuration.

To set the cpu.shares of the cpulimited group to 512, enter the following command:

The code is as follows:

Sudo cgset-r cpu.shares=512 cpulimited

Use the cgexec command to start the running of the control group. To test these two control groups, we first use the cpulimited control group to start the matho-primes process, as follows:

The code is as follows:

Sudo cgexec-g cpu:cpulimited / usr/local/bin/matho-primes 0 9999999999 > / dev/null &

When you open top, you can see that the matho-primes process takes up all the cpu resources.

Because there is only one process running on the system, no matter which control group it is started in, it will use as many cpu resources as possible. Cpu resource restrictions take effect only if two processes compete for cpu resources.

So, now let's start the second matho-primes process, this time in the lesscpulimited control group:

The code is as follows:

Sudo cgexec-g cpu:lesscpulimited / usr/local/bin/matho-primes 0 9999999999 > / dev/null &

If you open top again, you can see that the control group with a high cpu.shares value will get more cpu elapsed time.

Now, let's add another matho-primes process to the cpulimited control group:

The code is as follows:

Sudo cgexec-g cpu:cpulimited / usr/local/bin/matho-primes 0 9999999999 > / dev/null &

See, the cpu occupancy rate of the two control groups is still 2:1. Among them, the two matho-primes processes in the cpulimited control group got almost the same cpu time, while the matho-primes processes in the other group obviously got more running time.

For more information on how to use it, you can view the detailed instructions for using cgroups on Red Hat. (of course CentOS 7 also has it.)

Use Scout to monitor cpu occupancy

What is the easiest way to monitor cpu occupancy? The Scout tool can monitor cpu usage and memory usage that can automatically monitor processes.

The trigger function of Scout can also set the use threshold of cpu and memory, and an alarm will be automatically generated when the door limit is exceeded.

You can get a trial version of Scout here.

Summary

The system resources of computers are very valuable. The three tools described above can help you manage system resources effectively, especially cpu resources:

Nice can adjust the priority of the process at once.

Cpulimit is useful when running cpu-intensive tasks while keeping the system responsive.

Cgroups is a Swiss Army knife for resource management, and it is also flexible in use.

Thank you for your reading, the above is the content of "how to limit the occupancy rate of CPU in the Linux system". After the study of this article, I believe you have a deeper understanding of how to limit the occupancy rate of CPU in the Linux system. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

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.