Linux kernel process management and scheduling
I. Introduction
Today I will give you some hard goods. The process management and scheduling of Linux is a must-learn knowledge for learning and understanding Linux. In order to coordinate multiple processes to run "simultaneously" , modern operating systems usually use the basic method of process priority. Each process has a priority associated with it, and if there are multiple executable processes waiting for CPU resources, the process with the higher priority will be scheduled for execution first. Today I will explain to you the process management and scheduling in the Linux kernel. The content of the article is long, so please remember to like it first and then read it.
2. Process management and multi-process scheduling
2.1 Process identifiers and control blocks
A process identifier is a unique number that identifies each running process. In Linux, the process ID (PID) usually starts from 1 and increments. In the system, the kernel maintains a data structure for each process, called a process control block (PCB), also known as a process descriptor. The PCB stores all process-related information, including process status, PID, process priority, page table and resource usage statistics, and more.
2.2 Process states and transitions
In Linux, each process has a state machine, which can be in the ready state, running state, blocked state or dead state. in:
- Ready state : Refers to a process that is ready to be allocated CPU and start executing.
- Running state : refers to the current process that is occupying CPU resources.
- Blocking state : Refers to a process that is suspended for some reason and cannot occupy CPU resources.
- Zombie state : It means that the process has ended, but its parent process has not reclaimed the resources of the process.
Changes often occur between process states. For example, a process that changes from a blocked state to a ready state needs an event to release the blockage, and at this time the state of the process will change accordingly.
2.3 Inter-process communication
Information exchange and data sharing are required between different processes, so Linux provides a variety of inter-process communication mechanisms, such as pipes, message queues, semaphores, and shared memory. These mechanisms allow processes to safely exchange data and coordinate the behavior of different processes through various synchronization methods.
In the Linux system, when inter-process communication is implemented through pipes, the sender process puts data into the pipe buffer, and the receiver process reads data from the buffer. The message queue is a message container. The sending process can put data into the container and set a specific type, and the receiver process gets the data from the container according to the type. Shared memory allows different processes to access the same piece of physical memory, making it easy to share data between processes.
3. Linux process scheduling under single processor
3.1 Linux process scheduler
In the Linux kernel, the process scheduler (Scheduling Class) is a module responsible for selecting the next process to be executed. The Linux 2.6 kernel provides CFS (Completely Fair Scheduler) as the default process scheduling algorithm. This algorithm distributes CPU fairly to all "runnable" or "ready to run" processes. This means that even with one long-running process, other processes still get plenty of opportunity to use the CPU.
3.2 Time slice round-robin scheduling algorithm
Round Robin Scheduling (Round Robin Scheduling), also known as round robin scheduling algorithm, is a scheduling method based on time slices. In this algorithm, the operating system arranges each process to be executed into a queue, and each process is assigned a time slice of a fixed size. One dispatch.
The feature of the round robin scheduling algorithm is that it is simple and easy to implement, and it can ensure that all processes have the opportunity to be scheduled for execution. But as modern computers get faster and faster, the time slice may become too small, causing too many process switches and affecting CPU performance.
3.3 Shortest remaining time priority scheduling algorithm
In the Shortest Remaining Time First scheduling algorithm (Shortest Remaining Time First), the scheduler will decide which process to schedule next according to the CPU running time required by each process. If the currently running process takes longer than another ready process, preempts the current process and transfers execution to the new process.
This approach ensures that each process gets the running time it needs, but when there are many short processes, long-running processes may be noticeably ignored. Even with such a scheduling algorithm, the "starvation" phenomenon cannot be eliminated. Specifically, some processes may never get enough CPU time, and in worst cases can even have a severe impact on system performance.
3.4 Deficiencies of other scheduling algorithms
The problem with time-slice round-robin and least-remaining-time-first scheduling algorithms is that neither guarantees fairness, and thus may cause some processes to starve or procrastinate. Furthermore, these algorithms are usually designed for a single processor and cannot take full advantage of the multi-core and multi-thread nature of modern computer systems. It seems that the advantages and disadvantages of these two algorithms are relatively obvious, and they complement each other. Therefore, Linux process management and multi-process scheduling require other more adaptive algorithms, such as scheduling strategies based on the number of threads or load balancing.
4. Linux process scheduling under multiprocessor
4.1 Load balancing under symmetric multiprocessing architecture
In a symmetric multi-processing architecture (Symmetric Multi-Processor, SMP), all processors are equal, and each processor can access shared memory. Under this architecture, the Linux kernel usually uses a load balancing algorithm to balance the workload of multiple processors to improve system efficiency. For example, in the CFS algorithm, the Linux kernel uses a red-black tree to maintain a queue of processes waiting to be executed, and maintains load balance by minimizing the minimum load difference across the system.
4.2 Optimization under asymmetric multiprocessing architecture
In an asymmetric multi-processing architecture (Asymmetric Multi-Processor, AMP), processors are usually assigned to different tasks, so they cannot directly access shared memory. In this case, in order to maximize the performance of the system, it is necessary to consider better distribution of tasks among multiple processors.
A common approach is to use a "leader" or "master node" to coordinate the tasks of individual processors. The master node assigns tasks to each processor and monitors their operation. If a processor fails or becomes too busy, the master node redistributes tasks, keeping the system in an optimal state.
4.3 Multi-queue scheduling algorithm
The multi-queue scheduling algorithm is a scheduling algorithm that can be used in multi-processor systems. It maximizes the utilization of multiprocessor system resources by assigning each processor to an independent run queue. In the multi-queue scheduling algorithm, the scheduler dynamically distributes tasks to these run queues and performs required operations. This algorithm can reduce the competition situation caused by different processes sharing processor cores, and can maintain high efficiency and fairness while satisfying load balancing.
It should be pointed out that since modern computers usually have multiple CPU cores, Linux process scheduling and management under multi-processors is still a broad and active field, and researchers have been exploring different techniques and algorithms to solve new problems. problems and improve system performance.
5. CFS completely fair scheduling
5.1 CFS design ideas and principles
CFS (Completely Fair Scheduler) is the default process scheduling algorithm of the Linux kernel, and its design goal is to achieve "completely fair" scheduling. The way CFS achieves this goal is to assign a virtual running time to each process, and then schedule it according to the share of CPU requested by the process. If a process is taking fewer CPU clocks than other processes, CFS will increase its priority to ensure that it gets more CPU time in a timely manner. Conversely, if a process is using more CPU clocks than its requested share, its priority is lowered, freeing up the CPU and giving other processes waiting to be scheduled a chance to gain CPU execution.
In CFS, processes are arranged in a red-black tree and are said to be queued "based on their cumulative running time". A process with a short cumulative running time is given priority in the queue over a lower priority process with a long cumulative running time. Calculating the length of each node in a red-black tree requires complex tree recounting.
5.2 CFS characteristics and performance advantages and disadvantages
CFS has the following main characteristics:
- Completely fair : CFS tries to give all processes as much equal CPU time as possible.
- Delay-sensitive : CFS guarantees the real-time performance of data structures by controlling time allocation, so that delay-sensitive applications can obtain stable response times.
- Good scalability : CFS is easy to expand to multi-core processors and large-scale systems.
- No starvation : CFS pre-calculates the required time slice for each process to ensure that all processes get a suitable execution time.
However, CFS also has some limitations. Since CFS adopts a dynamic fair scheduling strategy based on red-black trees, time-consuming calculations are required each time the red-black trees are traversed, which may reduce system performance and responsiveness. In addition, CFS cannot completely eliminate problems such as improper control of CPU resources or high CPU usage.
5.3 Using skills of CFS combined with debugging and analysis tools
When actually using CFS, it is also necessary to combine relevant debugging and analysis tools to optimize performance and solve problems. For example, the number of processes, CPU usage, and memory usage in the current system can be checked through the top command, as shown in the following figure:
Another useful debugging tool is schedstat, which displays the statistics of the CFS scheduler. Through these display items, you can understand the time and resources consumed by each process in the system. Finally, it should be noted that although CFS is one of the default process scheduling algorithms of the Linux kernel, it is only applicable to Linux 2.6 and later versions, and other operating systems or versions may not support this algorithm.