解析 Linux 内核调度框图 【30字】 (linux 内核调度框图)

解析 Linux 内核调度框图，优化系统效率与稳定性 【1500字】

Linux操作系统是一种广泛应用的开源软件系统，其内核是系统的核心部分，其中的调度器可以进行进程、线程的管理调度，优化系统效率与稳定性。本文将深入解析Linux内核调度框图，帮助读者更好地理解Linux操作系统的调度机制，如何优化调度以及如何避免一些常见的调度问题。

一、Linux调度器简介

Linux内核中常用的调度器有两种，分别是CFS（Completely Fr Scheduler）和O(1)调度器，这两种调度器的优缺点如下：

CFS调度器优点：

1. 公平调度，实现平等竞争；

2. 合理分配CPU资源，降低程序之间的相互干扰；

3. 实现等比例切片调度；

4. 执行短进程速度较快。

CFS调度器缺点：

1. 实时性较差，无法保证在实时行为中的响应度；

2. 上下文切换次数较多，会增加CPU资源开销；

3. 通常涉及较大的负载均衡活动。

O(1)调度器优点：

1. 在对实时任务优先级的处理方面，有更好的支持；

2. 在所有系统上实现的常量负载下，可以保持更好的性能表现。

O(1)调度器缺点：

1. 不适合较大的系统；

2. 不适合大量长时间运行的进程。

根据不同的应用场景，可以选择不同的调度器进行调度。

二、Linux调度框图结构

进程的调度是Linux内核的一项重要任务，Linux调度器能够根据进程的状态进行管理调度工作，实现平等竞争和合理分配CPU资源的功能。图1是Linux内核调度框图示意图。


1. 进程调度

进程的调度是指按照一定的规则将处于就绪态的进程或者正在运行的进程从当前CPU中暂时踢出，以便其他就绪进程或者等待进程能够获得执行的机会。在Linux操作系统中，进程可以通过系统调用fork()，以及后续的exec()、wt()、exit()等函数来创建、执行、等待和结束，它们最终通过调度器来进行管理调度。

2. 中断调度

中断调度是指在中断请求到来时，将CPU的控制权转交给中断处理程序，并在处理完毕后将控制权回归给被打断的程序或者进程。Linux中断调度器能够处理Linux系统中的各种硬件中断事件，由于中断的处理需要极高的闪电速度，因此中断调度器需要优先处理中断事件。

3. 定时器调度

定时器调度是指Linux内核通过管理定时器列表，依次执行到期的任务处理程序。定时器调度可以保证所有的任务按时执行，并且能够及时检测和处理到期任务，避免了任务处理的延迟和丢失。

4. 实时调度

实时调度是指在实时系统中实现对进程和线程的优先级调度，并尽可能快的响应用户程序的运行。这种调度方法优先处理高优先级的进程，保证系统的实时性能。

5. 自愈调度

自愈调度是指Linux内核通过计算程序的线程数、进程数、负载并调整进程的运行状态，以此优化进程的使用率和系统速度。自愈调度能够自动缓解系统的性能压力，使系统在负载、峰值时间也能运行得比较稳定。

6. 负载均衡

负载均衡是指Linux内核通过检测CPU的使用率、负载，并调整运行在不同CPU上的进程的状态，使各个CPU之间的负载尽量平衡。负载均衡能够在大型服务器应用场景中，实现多个CPU核心之间的负载均衡，提高系统的的可靠性和扩展性。

7. CPU驱动程序

CPU驱动程序是指Linux内核依据CPU的性能、架构以及适配信息来动态确定调度的方式，实现了针对每个不同的CPU类型的专有的调度算法。CPU的调度对于整个系统的稳定性、效率有非常大的影响，而CPU驱动程序则能根据不同CPU的性能特点进行优化调度，提高系统的效能。

三、Linux调度优化

1. 优化系统启动

Linux启动时会运行一些无关紧要的任务，因此需要禁用这些任务来提高启动时的速度，同时可以对内存进行优化，减少硬盘I/O和内存开销，提高系统性能。

2. 编译内核时选用优化参数

在Linux内核编译时，可以根据CPU的架构和型号，使用优化参数，以帮助Linux内核有效的使用CPU。一般情况下，较新的版本的GCC会默认使用多个参数进行优化。

3. 保持更新内核版本

更新内核版本是保持系统性能稳定性的重要措施之一，每个版本都会修复一些内核问题，对于安全性能问题，内核更新可能是解决这些问题的唯一措施。

4. 配置虚拟内存

配置虚拟内存可以提高系统的性能，通过在硬盘上创建交换文件，完成RAM内部内存受到的限制，从而扩展系统的内存容量，提高系统的性能和稳定性。

5. 访问应用性能调优

访问性能的调优能够有效提高系统性能，例如将频繁访问的文件或文件系统放在较快的磁盘上，进行系统缓存的优化等。

四、避免常见调度问题

1. 进程饥饿

进程饥饿是指进程无法获得需要的CPU时间，导致陷入等待状态。进程饥饿可以通过优化调度策略来解决。

2. 进程优先级翻转

进程优先级翻转是指一个高优先级的进程被一个中等优先级的进程和一个低优先级的进程绑架，造成高优先级的进程无法完成工作等问题。避免进程优先级翻转可以通过调整处理机关键节点的互斥竞争顺序。

3. 优先级反转

优先级反转是指高优先级进程被低优先级进程的锁挂起，而无法获得锁，造成进程在等待锁的过程中，优先级被中断更低的进程抢占。避免优先级反转问题，可以考虑延迟锁的释放或者使用优先级继承技术等。

：通过深入解析Linux内核调度框图，本文详细阐述了Linux操作系统底层调度的机制和优化技术。Linux调度器可以针对不同的应用场景实现不同的调度方式，提高系统效率和稳定性。对于避免常见的调度问题，可以通过调整调度策略和技术手段来解决。

相关问题拓展阅读：

• linux内核同步问题

linux内核同步问题

Linux内核设计与实现 十、内核同步方法

手把手教Linux驱动5-自旋锁、信号量、互斥体概述

==

基础概念：

==

并发

：多个执行单元同时进行或多个执行单元微观串行执行，宏谨拿观并行执行

竞态

：并发的执行单元对共享资源（硬件资源和软件上的全局变量）的访问而导致的竟态状态。

临界资源

：多个进程访问的资源

临界区

：多个进程访问的代码段

==

并发场合：

==

1、单CPU之间进程间的并发

:时间片轮转，调度进程。 A进程访问打印机，时间片用完，OS调度B进程访问打印机。

2、单cpu上进程和中断之间并发

：CPU必须停止当前进程的执行中断;

3、多cpu之间

4、单CPU上中断之间的并发

==

使用偏向：

==

==信号量用于进程之间的同步，进程在信号量保护的临界区代码里面是可以睡眠的（需要进行进程调度），这是与自旋锁更大的区别。==

信号量又称为信号灯，它是用来协调不同进程间的数据对象的，而最主要的应用是共享内存方式的进程间通信。本质上，信号量是一个计数器，它用来记录对某个资源（如共享内存）的存取状况。它负责协调各个进程，以保证他们能够正确、合理的使用公共资源。它和spin lock更大的不同之处就是：无法获取信号量的进程可以睡眠祥李搭，因此会导致系统调度。

1、==用于进程与进程之间的同步==

2、==允许多个进程进入临界区代码执行，临界区代码允许睡眠；==

3、信号量本质是==基于调度器的==，在UP和P下没有区别；进程获取不到信号量将陷入休眠，并让出CPU；

4、不支持进程和中断之间的同步

5、==进程调度也是会消耗系统资源的，如果一个int型共享变量就需要使用信号量，将极大的浪费系统资源==

6、信号量可以用于多个线程，用于资源的计数（有多种状态）

==信号量加锁以及解锁过程：==

sema_init(&sp->dead_sem, 0); /

初始化

/

down(&sema);

临界区代码

up(&sema);

==信号量定义：==

==信号量初始化：==

==dowm函数实现扰高：==

==up函数实现：==

信号量一般可以用来标记可用资源的个数。

举2个生活中的例子：

==dowm函数实现原理解析：==

（1）down

判断sem->count是否 > 0，大于0则说明系统资源够用，分配一个给该进程，否则进入__down(sem);

（2）__down

调用__down_common(sem, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);其中TASK_UNINTERRUPTIBLE=2代表进入睡眠，且不可以打断；MAX_SCHEDULE_TIMEOUT休眠最长LONG_MAX时间；

（3）list_add_tail(&waiter.list, &sem->wait_list);

把当前进程加入到sem->wait_list中；

（3）先解锁后加锁;

进入__down_common前已经加锁了，先把解锁，调用schedule_timeout(timeout)，当waiter.up=1后跳出for循环；退出函数之前再加锁；

Linux内核ARM构架中原子变量的底层实现研究

rk3288 原子操作和原子位操作

原子变量适用于只共享一个int型变量；

1、原子操作是指不被打断的操作，即它是最小的执行单位。

2、最简单的原子操作就是一条条的汇编指令(不包括一些伪指令，伪指令会被汇编器解释成多条汇编指令)

==常见函数：==

==以atomic_inc为例介绍实现过程==

在Linux内核文件archarmincludeaatomic.h中。 执行atomic_read、atomic_set这些操作都只需要一条汇编指令，所以它们本身就是不可打断的。 需要特别研究的是atomic_inc、atomic_dec这类读出、修改、写回的函数。

所以atomic_add的原型是下面这个宏：

atomic_add等效于：

result（%0） tmp（%1） (v->counter)（%2） (&v->counter)（%3） i（%4）

注意：根据内联汇编的语法，result、tmp、&v->counter对应的数据都放在了寄存器中操作。如果出现上下文切换，切换机制会做寄存器上下文保护。

（1）ldrex %0,

意思是将&v->counter指向的数据放入result中，并且（分别在Local monitor和Global monitor中）设置独占标志。

（2）add %0, %0, %4

result = result + i

（3）strex %1, %0,

意思是将result保存到&v->counter指向的内存中，

此时 Exclusive monitors会发挥作用，将保存是否成功的标志放入tmp中。

（4） teq %1, #0

测试strex是否成功（tmp == 0 ？？）

（5）bne 1b

如果发现strex失败，从（1）再次执行。

Spinlock 是内核中提供的一种比较常见的锁机制，==自旋锁是“原地等待”的方式解决资源冲突的==，即，一个线程获取了一个自旋锁后，另外一个线程期望获取该自旋锁，获取不到，只能够原地“打转”（忙等待）。由于自旋锁的这个忙等待的特性，注定了它使用场景上的限制 —— 自旋锁不应该被长时间的持有（消耗 CPU 资源），一般应用在==中断上下文==。

1、spinlock是一种死等机制

2、信号量可以允许多个执行单元进入，spinlock不行，一次只能允许一个执行单元获取锁，并且进入临界区，其他执行单元都是在门口不断的死等

3、由于不休眠，因此spinlock可以应用在中断上下文中；

4、由于spinlock死等的特性，因此临界区执行代码尽可能的短；

==spinlock加锁以及解锁过程：==

spin_lock(&devices_lock);

临界区代码

spin_unlock(&devices_lock);

==spinlock初始化==

==进程和进程之间同步==

==本地软中断之间同步==

==本地硬中断之间同步==

==本地硬中断之间同步并且保存本地中断状态==

==尝试获取锁==

==

arch_spinlock_t结构体定义如下：

==

==

arch_spin_lock的实现如下：

==

lockval（%0） newval（%1） tmp（%2） &lock->slock（%3） 1 slock的值赋值给lockval；并且（分别在Local monitor和Global monitor中）设置独占标志。

（2）add %1, %0, %4

newval =lockval +（1slock指向的内存中，

此时 Exclusive monitors会发挥作用，将保存是否成功的标志放入tmp中。

（4） teq %2, #0

测试strex是否成功

（5）bne 1b

如果发现strex失败，从（1）再次执行。

通过上面的分析，可知关键在于strex的操作是否成功的判断上。而这个就归功于ARM的Exclusive monitors和ldrex/strex指令的机制。

（6）while (lockval.tickets.next != lockval.tickets.owner)

如何lockval.tickets的next和owner是否相等。相同则跳出while循环，否则在循环内等待判断；

*

（7）wfe()和p_mb() 最终调用#define barrier()

a

volatile

(“”: : :”memory”) *

阻止编译器重排，保证编译程序时在优化屏障之前的指令不会在优化屏障之后执行。

==

arch_spin_unlock的实现如下：

==

退出锁时：tickets.owner++

==

出现死锁的情况：

==

1、拥有自旋锁的进程A在内核态阻塞了，内核调度B进程，碰巧B进程也要获得自旋锁，此时B只能自旋转。 而此时抢占已经关闭，（单核）不会调度A进程了，B永远自旋，产生死锁。

2、进程A拥有自旋锁，中断到来，CPU执行中断函数，中断处理函数，中断处理函数需要获得自旋锁，访问共享资源，此时无法获得锁，只能自旋，产生死锁。

==

如何避免死锁：

==

1、如果中断处理函数中也要获得自旋锁，那么驱动程序需要在拥有自旋锁时禁止中断；

2、自旋锁必须在可能的最短时间内拥有

3、避免某个获得锁的函数调用其他同样试图获取这个锁的函数，否则代码就会死锁；不论是信号量还是自旋锁，都不允许锁拥有者第二次获得这个锁，如果试图这么做，系统将挂起；

4、锁的顺序规则（a) 按同样的顺序获得锁；b) 如果必须获得一个局部锁和一个属于内核更中心位置的锁，则应该首先获取自己的局部锁 ;c) 如果我们拥有信号量和自旋锁的组合，则必须首先获得信号量；在拥有自旋锁时调用down(可导致休眠)是个严重的错误的；）

==

rw（read/write）spinlock：

==

加锁逻辑：

1、假设临界区内没有任何的thread，这个时候任何的读线程和写线程都可以键入

2、假设临界区内有一个读线程，这时候信赖的read线程可以任意进入，但是写线程不能进入；

3、假设临界区有一个写线程，这时候任何的读、写线程都不可以进入；

4、假设临界区内有一个或者多个读线程，写线程不可以进入临界区，但是写线程也无法阻止后续的读线程继续进去，要等到临界区所有的读线程都结束了，才可以进入，可见：==rw（read/write）spinlock更加有利于读线程；==

==

seqlock（顺序锁）：

==

加锁逻辑：

1、假设临界区内没有任何的thread，这个时候任何的读线程和写线程都可以键入

2、假设临界区内没有写线程的情况下，read线程可以任意进入；

3、假设临界区有一个写线程，这时候任何的读、写线程都不可以进入；

4、假设临界区内只有read线程的情况下，写线程可以理解执行，不会等待，可见：==seqlock（顺序锁）更加有利于写线程；==

读写速度

：

CPU > 一级缓存 > 二级缓存 > 内存

，因此某一个CPU0的lock修改了，其他的CPU的lock就会失效；那么其他CPU就会依次去L1 L2和主存中读取lock值，一旦其他CPU去读取了主存，就存在系统性能降低的风险；

mutex用于互斥操作。

互斥体只能用于一个线程，资源只有两种状态（占用或者空闲）

1、mutex的语义相对于信号量要简单轻便一些，在锁争用激烈的测试场景下，mutex比信号量执行速度更快，可扩展

性更好，

2、另外mutex数据结构的定义比信号量小;、

3、同一时刻只有一个线程可以持有mutex

4、不允许递归地加锁和解锁

5、当进程持有mutex时，进程不可以退出。

• mutex必须使用官方API来初始化。

• mutex可以睡眠，所以不允许在中断处理程序或者中断下半部中使用，例如tasklet、定时器等

==常见操作：==

struct mutex mutex_1;

mutex_init(&mutex_1);

mutex_lock(&mutex_1)

临界区代码；

mutex_unlock(&mutex_1)

==常见函数：==

=