linux内核调度与spinlock的相互关系

合集下载

linux同步介绍

内核同步介绍Linux设备驱动中必须解决的一个问题是多个进程对共享资源的并发访问，并发访问会导致竞态，linux提供了多种解决竞态问题的方式，这些方式适合不同的应用场景。

Linux内核是多进程、多线程的操作系统，它提供了相当完整的内核同步方法。

内核同步方法列表如下：中断屏蔽原子操作自旋锁读写自旋锁顺序锁信号量读写信号量BKL（大内核锁）Seq锁一、并发与竞态：定义：并发（concurrency）指的是多个执行单元同时、并行被执行，而并发的执行单元对共享资源（硬件资源和软件上的全局变量、静态变量等）的访问则很容易导致竞态（race conditions）。

在linux中，主要的竞态发生在如下几种情况：1、对称多处理器（SMP）多个CPU特点是多个CPU使用共同的系统总线，因此可访问共同的外设和存储器。

2、单CPU内进程与抢占它的进程3、中断（硬中断、软中断、Tasklet、底半部）与进程之间只要并发的多个执行单元存在对共享资源的访问，竞态就有可能发生。

如果中断处理程序访问进程正在访问的资源，则竞态也会会发生。

多个中断之间本身也可能引起并发而导致竞态（中断被更高优先级的中断打断）。

解决竞态问题的途径是保证对共享资源的互斥访问，所谓互斥访问就是指一个执行单元在访问共享资源的时候，其他的执行单元都被禁止访问。

访问共享资源的代码区域被称为临界区，临界区需要以某种互斥机制加以保护，中断屏蔽，原子操作，自旋锁，和信号量都是linux 设备驱动中可采用的互斥途径。

临界区和竞争条件：所谓临界区（critical regions）就是访问和操作共享数据的代码段，为了避免在临界区中并发访问，编程者必须保证这些代码原子地执行——也就是说，代码在执行结束前不可被打断，就如同整个临界区是一个不可分割的指令一样，如果两个执行线程有可能处于同一个临界区中，那么就是程序包含一个bug，如果这种情况发生了，我们就称之为竞争条件（race conditions），避免并发和防止竞争条件被称为同步。

Linux内核分析之调度算法

Linux内核分析之调度算法inux调度算法在2.6.32中采用调度类实现模块式的调度方式。

这样，能够很好的加入新的调度算法。

linux调度器是以模块方式提供的，这样做的目的是允许不同类型的进程可以有针对性地选择调度算法。

这种模块化结构被称为调度器类，他允许多种不同哦可动态添加的调度算法并存，调度属于自己范畴的进程。

每个调度器都有一个优先级，调度代码会按照优先级遍历调度类，拥有一个可执行进程的最高优先级的调度器类胜出，去选择下面要执行的那个程序。

linux上主要有两大类调度算法，CFS(完全公平调度算法）和实时调度算法。

宏SCHED_NOMAL主要用于CFS调度，而SCHED_FIFO和SCHED_RR主要用于实时调度。

如下面的宏定义：1./*2.* Scheduling policies3.*/4./*支援Real-Time Task的排程,包括有SCHED_FIFO與SCHED_RR.5.*/6.7./*(也稱為SCHED_OTHER): 主要用以排程8.一般目的的Task.*/9.#define SCHED_NORMAL 010.#define SCHED_FIFO 111./*task預設的Time Slice長度為100 msecs*/12.#define SCHED_RR 213./*主要用以讓Task可以延長執行的時間14.(Time Slice),減少被中斷發生Task Context-Switch15.的次數.藉此可以提高Cache的利用率16.(每次Context-Switch都會導致Cache-Flush). 比17.較適合用在固定週期執行的Batch Jobs任18.務主機上,而不適合用在需要使用者互19.動的產品(會由於Task切換的延遲,而20.感覺到系統效能不佳或是反應太慢).*/21.#define SCHED_BATCH 322./* SCHED_ISO: reserved but not implemented yet */23./*為系統中的Idle Task排程.*/24.#define SCHED_IDLE 5linux调度算法实现的高层数据结构主要有运行实体、调度类、运行队列，下面我们主要看看这几个数据结构的字段和意义。

linux下软链接和硬链接的联系

linux下软链接和硬链接的联系1、索引节点：在linux系统中对文件的管理本质上是通过其索引节点进行管理的。

从系统的角度来看，文件的索引节点(inode)是文件的唯一标识，它包含了文件系统处理文件所需要的全部信息。

详细来说，实际上存在两种类型的索引节点内核索引节点(in-core indoe)：保存在内存中，在系统中每个打开的文件都对应着一个内核索引节点，磁盘索引节点(on-disk inode)：在文件系统中的每一个文件都有一个磁盘索引节点，保存在磁盘上，它所保存的具体信息与文件系统的类型有关。

注意：这两种索引节点的关系为：当进程打开一个文件时，文件的磁盘索引节点中的信息就会被载入内存，并建立一个内核索引节点。

当内核索引节点被修改后，系统负责将其同步到磁盘上。

磁盘索引节点与对应的内核索引节点所保存的信息并不是完全相同的。

内核索引节点记录的是关于文件的更通用的一些信息，而忽略掉于具体文件系统类型相关的一些信息。

2、硬链接：就是让一个文件对应一个或者多个文件名，或者说文件名和文件系统使用的节点号链接起来，这些文件可以在同一目录或者不同目录下。

一个文件名对应多个文件名，称作该文件的链接数。

例如：ln [options] existingfile newfileln [options] existingfile-list directory用法：第一种为”existingfile”创建硬链接，文件名为”newfile”。

第二种在”directory”目录中，为” existingfile-list”中包含的所有文件创建一个同名的硬链接。

常用可选[options]：-f 无论”newfile”存在与否，都创建链接。

-n 如果”newfile”已存在，就不创建链接。

3、软链接：又称为符号链接，实际上是一中特殊的文件，这种文件包含了另一个文集那的.人一个路径名。

这个路径名指向位于任意一个文件系统的任意一个文件，甚至可以指向一个不存在的文件。

Linux内核同步机制简介分析

Linux内核同步机制简介1 介绍1)由于现代Linux操作系统是多任务、SMP、抢占式以及中断是异步执行的，导致共享资源容易被并发访问，从而使得访问共享资源的各线程之间互相覆盖共享数据，造成被访问数据处于不一致状态，因此Linux提供了同步机制来防止并发访问。

2)常用的同步机制（如自旋锁）用来保护共享数据使用起来简单有效，但由于CPU的处理速度与访问内存的速度差距越来越大，导致获取锁的开销相对于CPU的速度在不断的增加。

因为这种锁使用了原子操作指令，需要原子地访问内存，即获取锁的开销与访问内存的速度相关。

3)Linux内核根据对不同共享资源的特性，提供多种同步机制：原子操作、自旋锁、读-写自旋锁、信号量、读-写信号量、完成变量、顺序锁、禁止抢占、内存屏障及RCU，本文将对其分别进行简要介绍。

2 原子操作（atomic）2.1 基本原理1)所谓原子操作，就是该操作绝不会在执行完毕前被任何其它任务或事件打断，它是最小的执行单位，不可能有比它更小的执行单位。

2)原子操作通常是内联函数，通过内联汇编指令来实现。

3)原子操作需要硬件的支持，因此不同的体系结构的实现方式不同。

4)内核提供了两组原子操作接口：整数操作和位操作。

2.1.2 原子整数操作1)原子操作主要用于实现资源计数，很多引用计数就是通过原子操作实现的。

2)原子类型定义如下：（参看RHEL6.5GA_x86_64内核文件：/root/include/linux/types.h）3)针对整数的原子操作只能对atomic_t类型的数据进行处理，原因如下：a)让原子函数只接受atomic_t类型的操作数，可以确保原子操作只与这种特殊类型一起使用。

b)使用atomic_t类型确保编译器不对相应的值进行优化，使得原子操作最终接收到正确的内存地址。

c)可以屏蔽不同体系结构上实现原子操作的差异。

2.1.2 原子位操作1)位操作函数是对普通的内存地址进行操作的，对所操作的数据类型没有要求。

Linux内核中的同步机制【转载】

本文周详的介绍了Linux内核中的同步机制：原子操作、信号量、读写信号量和自旋锁的API，使用需求及一些典型示例一、引言在现代操作系统里，同一时间可能有多个内核执行流在执行，因此内核其实象多进程多线程编程相同也需要一些同步机制来同步各执行单元对共享数据的访问。

尤其是在多处理器系统上，更需要一些同步机制来同步不同处理器上的执行单元对共享的数据的访问。

在主流的Linux内核中包含了几乎所有现代的操作系统具有的同步机制，这些同步机制包括：原子操作、信号量（semaphore）、读写信号量（rw_semaphore）、spinlock、BKL(Big Kernel Lock)、rwlock、brlock（只包含在2.4内核中）、RCU（只包含在2.6内核中）和seqlock（只包含在2.6内核中）。

二、原子操作所谓原子操作，就是该操作绝不会在执行完毕前被所有其他任务或事件打断，也就说，他的最小的执行单位，不可能有比他更小的执行单位，因此这里的原子实际是使用了物理学里的物质微粒的概念。

原子操作需要硬件的支持，因此是架构相关的，其API和原子类型的定义都定义在内核源码树的include/asm/atomic.h文件中，他们都使用汇编语言实现，因为C语言并不能实现这样的操作。

原子操作主要用于实现资源计数，非常多引用计数(refcnt)就是通过原子操作实现的。

原子类型定义如下：typedef struct{volatile int counter;}atomic_t;volatile修饰字段告诉gcc不要对该类型的数据做优化处理，对他的访问都是对内存的访问，而不是对寄存器的访问。

原子操作API包括：atomic_read(atomic_t * v);该函数对原子类型的变量进行原子读操作，他返回原子类型的变量v的值。

atomic_set(atomic_t * v, int i);该函数设置原子类型的变量v的值为i。

Linux_C_同步_内核原子_自旋锁_互斥锁

Linux 同步方法剖析内核原子，自旋锁和互斥锁你也许接触过并发（concurrency）、临界段（critical section）和锁定，不过怎么在内核中使用这些概念呢？本文讨论了 2.6 版内核中可用的锁定机制，包括原子运算符（atomic operator）、自旋锁（spinlock）、读/写锁（reader/writer lock）和内核信号量（kernel semaphore）。

本文还探讨了每种机制最适合应用到哪些地方，以构建安全高效的内核代码。

本文讨论了 Linux 内核中可用的大量同步或锁定机制。

这些机制为 2.6.23 版内核的许多可用方法提供了应用程式接口（API）。

不过在深入学习 API 之前，首先需要明白将要解决的问题。

并发和锁定当存在并发特性时，必须使用同步方法。

当在同一时间段出现两个或更多进程并且这些进程彼此交互（例如，共享相同的资源）时，就存在并发现象。

在单处理器（uniprocessor，UP）主机上可能发生并发，在这种主机中多个线程共享同一个 CPU 并且抢占（preemption）创建竞态条件。

抢占通过临时中断一个线程以执行另一个线程的方式来实现 CPU 共享。

竞态条件发生在两个或更多线程操纵一个共享数据项时，其结果取决于执行的时间。

在多处理器（MP）计算机中也存在并发，其中每个处理器中共享相同数据的线程同时执行。

注意在 MP 情况下存在真正的并行（parallelism），因为线程是同时执行的。

而在 UP 情形中，并行是通过抢占创建的。

两种模式中实现并发都较为困难。

Linux 内核在两种模式中都支持并发。

内核本身是动态的，而且有许多创建竞态条件的方法。

Linux 内核也支持多处理（multiprocessing），称为对称多处理（SMP）。

临界段概念是为解决竞态条件问题而产生的。

一个临界段是一段不允许多路访问的受保护的代码。

这段代码能操纵共享数据或共享服务（例如硬件外围设备）。

linux锁机制分析

Linux 锁机制分析batoom1.加锁的原因是因为在对共享数据或者共享资源进行并发访问的时候，会使数据错乱。

例如：very_important_count++期望的结果这种结果依赖于多个任务的相对执行顺序，叫做竞态条件(race ondition）。

包含并发问题的代码叫做临界区。

这种情况在SMP机器上更加明显，上面的例子是单CPU由于抢占造成的。

2.在linux内核中加锁linux内核中主要有两种类型的锁：1)自旋锁spinlock当获取不成功时，不会睡眠，会一直循环查找锁是否被释放，必须在不能睡眠的代码中使用。

在单cpu没有打开抢占的情况下，自选锁相当于不存在，在打开抢占的情况下，自选锁的作用是禁止抢占。

#define spin_lock(lock) _spin_lock(lock) #define _spin_lock(lock) __LOCK(lock)#define __LOCK(lock) \do { preempt_disable(); __acquire(lock); (void)(lock); } while (0) 注意到“preempt_disable()”，这个调用的功能是“关抢占”（在spin_unlock中会重新开启抢占功能）。

从中可以看出，使用自旋锁保护的区域是工作在非抢占的状态；即使获取不到锁，在“自旋”状态也是禁止抢占的。

使用方法：Static spinlock_t xxx_lock = SPIN_LOCK_UNLOCKED;spin_lock(&xxx_lock);…spin_unlock(&xxx_lock);2)信号量semaphone只有一个持有者的信号量叫mutex，当获取不成功时，任务会把自身放到一个队列中睡眠，一直等到信号量被释放时才唤醒。

必须在能睡眠的代码中使用。

void down(struct semaphore *sem){unsigned long flags;spin_lock_irqsave(&sem->lock, flags);if (likely(sem->count > 0))sem->count--;else__down(sem);spin_unlock_irqrestore(&sem->lock, flags);}for (;;) {if (signal_pending_state(state, task))goto interrupted;if (timeout <= 0)goto timed_out;__set_task_state(task, state);spin_unlock_irq(&sem->lock);timeout = schedule_timeout(timeout);spin_lock_irq(&sem->lock);if (waiter.up)return 0;}schedule_timeout函数是把当前进程推入等待列表，并在timeout时间后唤醒。

linux内核锁实现原理

linux内核锁实现原理Linux内核锁是Linux操作系统中实现多线程同步和互斥的一种机制。

在并发编程中，多个线程同时访问共享资源时，为了避免出现数据竞争和不一致的情况，需要使用锁来保护共享资源的访问。

Linux内核提供了多种类型的锁，例如互斥锁（mutex）、读写锁（rwlock）、自旋锁（spinlock）等。

不同类型的锁适用于不同的场景和需求。

下面将详细介绍Linux内核锁的实现原理。

1. 互斥锁（Mutex）：互斥锁是最常用的一种锁，用于实现对临界区的互斥访问。

Linux 内核中的互斥锁实现主要依赖于原子操作和等待队列。

原子操作用于实现锁的获取和释放操作，保证了这些操作的原子性，避免了竞态条件。

等待队列用于管理等待锁的线程，当一个线程尝试获取锁失败时，会被放入等待队列中，直到锁被释放后再唤醒等待队列中的线程。

2. 读写锁（RWLock）：读写锁是一种特殊的锁，用于实现对共享资源的读写操作。

它允许多个线程同时读取共享资源，但在写操作时必须互斥。

Linux内核中的读写锁实现主要依赖于原子操作和等待队列。

读操作不需要加锁，只有写操作需要加锁。

读写锁内部维护了两个计数器，一个用于记录读操作的数量，一个用于记录写操作的数量。

读操作时，会增加读计数器；写操作时，会判断读计数器和写计数器是否为零，如果不为零则等待；如果为零则增加写计数器。

当读操作和写操作完成后，会相应地减少计数器。

3. 自旋锁（Spinlock）：自旋锁是一种特殊的锁，用于实现对临界区的互斥访问。

与互斥锁不同的是，自旋锁不会主动释放CPU资源，而是一直尝试获取锁，直到获取成功。

自旋锁的实现主要依赖于原子操作。

当一个线程尝试获取自旋锁失败时，会不断地尝试获取锁，直到获取成功。

这种方式适用于临界区的持有时间很短的情况，避免了线程切换的开销。

除了上述常用的锁类型，Linux内核还提供了一些其他类型的锁，如信号量（Semaphore）、屏障（Barrier）等。

Mutex, semaphore, spinlock的深度解析

Mutex是一把钥匙，一个人拿了就可进入一个房间，出来的时候把钥匙交给队列的第一个。

一般的用法是用于串行化对critical section代码的访问，保证这段代码不会被并行的运行。

Semaphore是一件可以容纳N人的房间，如果人不满就可以进去，如果人满了，就要等待有人出来。

对于N=1的情况，称为binary semaphore。

一般的用法是，用于限制对于某一资源的同时访问。

Binary semaphore与Mutex的差异：在有的系统中Binary semaphore与Mutex是没有差异的。

在有的系统上，主要的差异是mutex一定要由获得锁的进程来释放。

而semaphore可以由其它进程释放（这时的semaphore实际就是个原子的变量，大家可以加或减），因此semaphore可以用于进程间同步。

Semaphore的同步功能是所有系统都支持的，而Mutex能否由其他进程释放则未定，因此建议mutex只用于保护critical section。

而semaphore则用于保护某变量，或者同步。

另一个概念是spin lock，这是一个内核态概念。

spin lock与semaphore的主要区别是spin lock是busy waiting，而semaphore是sleep。

对于可以sleep的进程来说，busy waiting 当然没有意义。

对于单CPU的系统，busy waiting当然更没意义（没有CPU可以释放锁）。

因此，只有多CPU的内核态非进程空间，才会用到spin lock。

Linux kernel的spin lock在非SMP的情况下，只是关irq，没有别的操作，用于确保该段程序的运行不会被打断。

其实也就是类似mutex的作用，串行化对critical section的访问。

但是mutex不能保护中断的打断，也不能在中断处理程序中被调用。

而spin lock也一般没有必要用于可以sleep的进程空间。

计算机操作系统(第二版)课件：Linux 进程调度算法解析

➢ 进程运行时间计算：
Ti=period *
Wi n Wi
i =1
例：系统有两个两个就绪进程A和B
WA=15（nice值19），WB=110（nice值10）：则： TA=2.4ms，TB=17.6ms
3.5.3 Linux/openEuler 进程调度算法解析
完全公平调度器：CFS
虚拟运行时间：vruntime ➢ 进程虚拟运行时间： VTi=T* 1024
Linux2.6内核的O(1)调度器
调度时间开销为O(1)，与系统中就绪进程数量无关
01
5
9
位 0 ●● 示1
图
设
置
8 9
队列数组
15
0
1
…
5
…
9
…
120
…
139
优先级队列
… …
3.5.3 Linux/openEuler 进程调度算法解析
1. Linux调度器的发展
Linux2.6内核的O(1)调度器
支持内核抢占，能更好地支持实时进程分散计算各进程优先级及时间片，减小了计算的时间开销根据一些经验公式调整进程优先级，适当照顾交互式进程
prio=max(100,min(static_prio-bonus+5,139))
3.5.3 Linux/openEuler 进程调度算法解析
1. Linux调度器的发展
Wi
232 1 VTi=1024*T * Wi * 232
struct load_weight {
unsigned long weight; // 进程权重W
inv_weight;
// 232/W的值
};

锁机制

Linux锁的分类1.spinlock 自旋锁2.rwlock 读写锁3.brlock big reader clock 高性能的rwlock 适用于读多写少的情况4.refcnt refcnt表示自旋锁与引用记数一起使用。

RCU并不是新的锁机制，它只是对Linux内核而言是新的。

下面开始介绍RCU。

一、引言众所周知，为了保护共享数据,需要一些同步机制,如自旋锁(spinlock)，读写锁(rwlock)，它们使用起来非常简单,而且是一种很有效的同步机制，在UNIX系统和Linux系统中得到了广泛的使用。

但是随着计算机硬件的快速发展，获得这种锁的开销相对于CPU的速度在成倍地增加，原因很简单，CPU的速度与访问内存的速度差距越来越大，而这种锁使用了原子操作指令，它需要原子地访问内存，也就说获得锁的开销与访存速度相关，另外在大部分非x86架构上获取锁使用了内存栅(Memory Barrier)，这会导致处理器流水线停滞或刷新，因此它的开销相对于CPU速度而言就越来越大。

表1数据证明了这一点。

表1是在700MHz的奔腾III机器上的基本操作的开销，在该机器上一个时钟周期能够执行两条整数指令。

在1.8GHz的奔腾4机器上, 原子加1指令的开销要比700MHz的奔腾III机器慢75纳秒(ns)，尽管CPU速度快两倍多。

这种锁机制的另一个问题在于其可扩展性，在多处理器系统上，可扩展性非常重要，否则根本无法发挥其性能。

图1表明了Linux上各种锁的扩展性。

图 1 Linux的4种锁机制的扩展性注：refcnt表示自旋锁与引用记数一起使用。

读写锁rwlock在两个CPU的情况下性能反倒比一个CPU的差，在四个CPU的情况下，refcnt的性能要高于rwlock，refcnt大约是理论性能的45%，而rwlock 是理论性能的39%,自旋缩spinlock的性能明显好于refcnt和rwlock，但它也只达到了理性性能的57%，brlock（Big Reader Lock）性能可以线性扩展。

linux 互斥锁信号量自旋锁实现原理

Linux中的互斥锁、信号量和自旋锁都是常用的同步机制，用于协调多个线程或进程对共享资源的访问。

1. 互斥锁（Mutex）：也称为互斥量，是最基本的锁机制。

它提供了互斥访问共享资源的能力，当一个线程获得互斥锁后，其他线程将被阻塞，直到该线程释放锁为止。

在Linux内核中，mutex 的实现原理基于底层硬件的支持，通过使用汇编指令实现锁的获取和释放。

2. 信号量（Semaphore）：信号量是一种计数器，用于控制对共享资源的访问次数。

在Linux内核中，信号量的实现原理基于系统调用和内核函数，通过维护一个计数器来记录可用资源数量。

当一个线程需要访问共享资源时，会尝试获取信号量，如果计数器为正数，则该线程可以访问共享资源，否则该线程将被阻塞。

3. 自旋锁（Spinlock）：自旋锁是一种基于忙等待的同步机制。

当一个线程尝试获取自旋锁时，如果锁已经被其他线程持有，则该线程将自旋（忙等待）直到锁被释放。

自旋锁适用于保护临界区代码较短且短暂占用共享资源的情况。

在Linux内核中，自旋锁的实现原理基于底层硬件的支持，通过使用汇编指令实现锁的获取和释放。

需要注意的是，以上三种锁机制都是通过系统调用或特定的库函数在用户空间或内核空间实现的。

在使用锁的过程中，需要注意
避免死锁（Deadlock）和饥饿（Starvation）等并发编程中常见的问题。

linux内核分析要点

linux内核分析--中断的分类什么是中断Linux 内核需要对连接到计算机上的所有硬件设备进行管理，毫无疑问这是它的份内事。

如果要管理这些设备，首先得和它们互相通信才行，一般有两种方案可实现这种功能：轮询（polling）让内核定期对设备的状态进行查询，然后做出相应的处理；中断（interrupt）让硬件在需要的时候向内核发出信号（变内核主动为硬件主动）。

第一种方案会让内核做不少的无用功，因为轮询总会周期性的重复执行，大量地耗用 CPU 时间，因此效率及其低下，所以一般都是采用第二种方案。

对于中断的理解我们先看一个生活中常见的例子:QQ。

第一种情况:你正在工作,然后你的好友突然给你发送了一个窗口抖动,打断你正在进行的工作。

第二种情况:当然你有时候也会每隔 5 分钟就去检查一下 QQ 看有没有好友找你,虽然这很浪费你的时间。

在这里,一次窗口抖动就可以被相当于硬件的中断,而你就相当于 CPU,你的工作就是 CPU 这在执行的进程。

而定时查询就被相当于 CPU 的轮询。

在这里可以看到:同样作为 CPU 和硬件沟通的方式,中断是硬件主动的方式,较轮询(CPU 主动)更有效些,因为我们都不可能一直无聊到每隔几分钟就去查一遍好友列表。

CPU 有大量的工作需要处理,更不会做这些大量无用功。

当然这只是一般情况下。

好了,这里又有了一个问题,每个硬件设备都中断,那么如何区分不同硬件呢?不同设备同时中断如何知道哪个中断是来自硬盘、哪个来自网卡呢?这个很容易,不是每个 QQ 号码都不相同吗?同样的,系统上的每个硬件设备都会被分配一个 IRQ 号,通过这个唯一的 IRQ 号就能区别张三和李四了。

从物理学的角度看，中断是一种电信号，由硬件设备产生，并直接送入中断控制器（如 8259A）的输入引脚上，然后再由中断控制器向处理器发送相应的信号。

处理器一经检测到该信号，便中断自己当前正在处理的工作，转而去处理中断。

此后，处理器会通知 OS 已经产生中断。

Linux 的 Spinlock 在 MIPS 多核处理器中的设计与实现

Spinlock 在Linux 中被广泛应用于解决多核处理器之间访问共享资源的互斥问题，本文以MIPS 多核处理器为例，介绍了Spinlock 的设计与实现，以及Spinlock 的不足与扩展。

引言随着科技的发展，尤其是在嵌入式领域，高性能、低功耗的处理器成为众多厂商追逐的目标，但是由于技术和工艺的瓶颈，试图在单核处理器上达到这样的目标变得越发困难，于是人们提出了多核处理器的概念。

多核处理器的核心思想是一个处理器中包含若干个核（或线程），所有核（或线程）之间共享IO、Cache、内存等资源，对于这些资源的使用和分配由硬件来完成，用户无需关注细节，因此每个核（或线程）对于用户来说就好像一个独立的虚拟CPU，从用户角度来看，这个虚拟CPU 独占所有的外设资源。

目前比较流行的多核处理器的架构有下面几种：（1）SMP（Symmetric Multi-P rocessor）这种架构的处理器由多个核组成，每个核有自己独立的Cache，所有核共享内存和IO。

（2）SMT（Symmetric Multi-Thread）这种架构的处理器的每个核由多个线程组成（此处的线程指的硬件线程，而不是我们所说的操作系统的线程概念），每个核下的所有线程共享寄存器、ALU（CPU 运算单元）、Cache、内存、IO 等资源，线程之于用户也像一个虚拟的CP U。

这种架构的最大优势在于线程和线程之间的切换很快，通常一个时钟周期内就能完成。

（3）NUMA（Non-Uniform Memory Access）这种架构和前面两种的区别在于它不是简单的一个处理器，而是一个由多个处理器组成的系统，每个处理器作为一个结点在该系统中存在。

对于内存、IO 等资源所有结点也是共享的。

目前比较流行的处理器架构大多都推出了多核处理器的产品，比如Intel 的X86 双核处理器、Freescale 的PPC 多核处理器、SUN 的SP ARC 多核处理器、RMI 和Cavium 的MIP S 多核处理器等。

LINUX内核的几种锁介绍

LINUX内核的几种锁介绍以下是LINUX内核中几种常见的锁的介绍：1. 自旋锁（spinlock）：自旋锁是一种基本的锁机制，在等待锁的过程中，线程会一直处于自旋状态，即不会让出CPU，而是一直不停地检测锁是否可用。

自旋锁适用于代码执行时间很短，期待锁很快就可以被释放的情况。

自旋锁的实现通过设置一个标志位来指示锁的状态，如果锁处于被占用状态，那么线程会不断地循环检测该标志位，直到锁的状态变为可用。

2. 读写锁（reader-writer lock）：读写锁是一种基于共享资源的并发控制机制，它允许多个线程同时读取共享资源，但在写操作时，必须互斥，即只允许一个线程进行写操作。

读写锁适用于读操作频繁而写操作较少的场景，可以提高系统的并发性能。

读写锁的实现需要维护两个计数器，分别用于记录当前读操作的线程数和写操作的线程数。

3. 互斥锁（mutex）：互斥锁是最常用的一种锁机制，也是最简单的一种。

互斥锁可以通过实现线程之间的互斥访问共享资源来保证数据的一致性。

在线程需要访问共享资源之前，会先尝试获取互斥锁，如果锁已经被其他线程占用，那么线程就会进入阻塞状态，直到锁被释放。

互斥锁可以保证同时只有一个线程在访问共享资源，从而避免了竞态条件的发生。

4. 信号量（semaphore）：信号量是一种更为复杂的锁机制，它可以控制对共享资源的访问权限。

信号量可以用来解决生产者-消费者问题、读写者问题等。

信号量分为二进制信号量（只能取0或1）和计数信号量（可以取多个非负整数）。

线程可以通过等待（wait）操作来获取信号量，如果信号量的值大于0，那么线程可以继续执行，如果信号量的值等于0，那么线程就会进入阻塞状态。

线程可以通过释放（post）操作来释放信号量，从而允许其他线程获取信号量。

5. 屏障（barrier）：屏障是一种同步机制，它可以确保多个线程在一些点上一起等待，直到所有线程都到达该点后才能继续执行。

屏障可以用来解决多线程计算中的数据依赖问题。

linux锁的底层实现机制

linux锁的底层实现机制Linux中的锁机制有很多种，包括互斥锁（mutex）、读写锁（rwlock）、自旋锁（spinlock）、信号量（semaphore）等。

它们在底层实现上使用了不同的数据结构和算法来保证资源的互斥访问和同步。

1. 互斥锁（mutex）：互斥锁是最常用的锁机制之一、它通过在竞争资源的临界区域设置一个标志位来实现互斥访问。

在Linux内核中，互斥锁通过spinlock和atomic 原子操作来实现。

spinlock是一种简单的自旋锁，它通过不断循环检查标志位来尝试获取锁，直到获取到为止。

如果获取不到锁，线程将一直处于忙等状态，这在资源竞争不频繁或临界区域很短暂的情况下是有效的。

spinlock适用于多处理器系统，因为在多处理器中，两个线程可以并行地竞争锁。

atomic 原子操作是一种特殊的操作，能够保证对一些变量的操作是不可中断的。

在获取互斥锁时，如果发现锁已经被其他线程持有，则使用原子操作暂时禁止中断，以保证获取和释放锁的原子性。

2. 读写锁（rwlock）：读写锁用于并发读和独占写的场景。

在内核中，读写锁是基于互斥锁实现的。

读锁可以被多个线程同时持有，读锁的获取与释放是非常快速的。

写锁是独占锁，只能被单个线程持有，其他线程在获取写锁时会被阻塞。

读写锁的底层实现使用了一个计数器和一个等待队列。

计数器用于记录当前读写锁的状态，等待队列用于管理等待读锁和写锁的线程。

如果一个线程尝试获取读锁时发现已经被另一个线程持有写锁，它将加入到等待队列中，直到写锁释放。

同样，一个线程尝试获取写锁时，如果发现已经被其他线程持有读锁或写锁，它也会加入到等待队列中。

3. 自旋锁（spinlock）：4. 信号量（semaphore）：信号量是一种通用的锁机制，它允许多个线程同时访问一些资源。

信号量的底层实现使用了原子操作和等待队列。

当一个线程需要访问资源时，它需要先获取信号量。

如果信号量的值大于0，则减小信号量的值并继续执行，表示获取资源。

linux调度算法代码

linux调度算法代码以下是Linux内核中的调度算法代码：1. CFS（Completely Fair Scheduler）CFS是Linux内核默认的调度器，它通过计算每个进程的虚拟运行时间（virtual runtime）来进行调度。

虚拟运行时间是根据进程消耗的CPU时间、进程优先级和进程权重等因素计算出来的。

CFS调度器的代码位于内核目录下的/kernel/sched目录中，具体代码如下：sched.cstruct sched_entity {...u64 vruntime;...};static inline u64 __sched_vruntime(struct sched_entity *se){return se->vruntime;}static inline u64 __sched_period(unsigned int period){return (u64)period * NSEC_PER_SEC;}static inline u64 sched_vruntime(volatile struct task_struct *p){struct sched_entity *se = &p->se;if (unlikely(se->vruntime == 0))return (__u64)(-(long long)(JIFFIES_TO_NS(1ULL))); 调度实体还未运行，返回一个负值return __sched_period(1000) * (u64)se->vruntime/ (u64)cfs_rq_runtime(&p->se) + schedstat_avg(jiffies -p->st_update_time);}2. BFS（Brain Fuck Scheduler）BFS是一种通过多层反馈调度的算法，它会根据进程的历史调度情况来调整进程的优先级。

Linux驱动设计——内核模块（一）

Linux驱动设计——内核模块（⼀）Linux内核理论基础组成Linux内核的5个⼦系统：进程调度（SCHED）/内存管理（MM）/虚拟⽂件系统（VFS）/⽹络接⼝（NET）/进程间通信（IPC）。

进程调度（SCHED）在设备驱动编程中，当请求的资源不能得到满⾜时，驱动⼀般会调度其他进程执⾏，并使本进程进⼊睡眠状态，直到它请求的资源被释放，才会被唤醒⽽进⼊就绪态。

睡眠分成可被打断的睡眠和不可被打断的睡眠，两者的区别在于可被打断的睡眠在收到信号的时候会醒。

内存管理（MM）内存管理的主要作⽤是控制多个进程安全地共享主内存区域。

当CPU 提供内存管理单元（MMU）时，Linux 内存管理完成为每个进程进⾏虚拟内存到物理内存的转换。

虚拟⽂件系统（VFS）Linux 虚拟⽂件系统（VFS）隐藏各种了硬件的具体细节，为所有的设备提供了统⼀的接⼝。

它独⽴于各个具体的⽂件系统，是对各种⽂件系统的⼀个抽象，它使⽤超级块super block 存放⽂件系统相关信息，使⽤索引节点inode 存放⽂件的物理信息，使⽤⽬录项dentry 存放⽂件的逻辑信息。

⽹络接⼝（NET）⽹络接⼝提供了对各种⽹络标准的存取和各种⽹络硬件的⽀持。

在Linux 中⽹络接⼝可分为⽹络协议和⽹络驱动程序，⽹络协议部分负责实现每⼀种可能的⽹络传输协议，⽹络设备驱动程序负责与硬件设备通信，每⼀种可能的硬件设备都有相应的设备驱动程序。

进程间通信（IPC）进程通信⽀持提供进程之间的通信，Linux ⽀持进程间的多种通信机制，包含信号量、共享内存、管道等，这些机制可协助多个进程、多资源的互斥访问、进程间的同步和消息传递。

Linux 内核的5 个组成部分之间的依赖关系如下：1、进程调度与内存管理之间的关系：这两个⼦系统互相依赖。

在多道程序环境下，程序要运⾏必须为之创建进程，⽽创建进程的第⼀件事情，就是将程序和数据装⼊内存。

2、进程间通信与内存管理的关系：进程间通信⼦系统要依赖内存管理⽀持共享内存通信机制，这种机制允许两个进程除了拥有⾃⼰的私有空间，还可以存取共同的内存区域。