linuxcpu调度

1. linux调度算法的核心思想是什么

第一部分：实时调度算法

什么是实时系统，POSIX 1003.b作了这样的定义：是指系统可以在有限响应时间内提供所需的服务级别。较可取被定义为由Donald乔利士的的：一个实时系统的程序的逻辑正确性不仅取决于计算的准确度，而且还对结果，如果系统时间的限制不能满足将是一个系统错误发生。

基于实时系统的实时性要求的不同，可分为软实时和硬实时两种。硬实时系统是指系统必须确保，在最坏情况下的服务时间，截止日期为事件的响应时间是在任何情况下，必须满足。如航天飞船的控制是这样一个系统的现实。所有其他实时系统的特点，可以称为软实时系统。如果清除，软实时系统是那些从统计学的角度来看，一个任务（在下面的讨论中，我们将有任务和过程不作出区分），以确保系统的处理时间，可以得到事件可以处理的最后期限到来之前，违反的最后期限，并不会带来一个致命的错误，如实时多媒体系统是一种软实时系统。

一台电脑系统的CPU和其他资源进行有效的调度和管理，以提供实时操作系统的支持。的多任务的实时系统中，资源的调度和管理更复杂的。下面讨论本文将从各种实时任务调度算法的分类的角度来看，普通的Linux操作系统进程调度和各种实时Linux系统，然后研究，以支持实时特点，普通的Linux系统的改进。实时领域的一些问题，并总结了各种实时Linux的Linux操作系统，归根到底是如何解决这些问题。

CPU的实时调度算法的分类

多种实时操作系统的实时调度算法可以分为以下三类Wang99] [Gopalan01]：基于优先级调度算法（优先级驱动调度PD），基于在共享的CPU使用率调度算法（分享驱动调度SD）的比例，以及基于时间的进程调度算法（时间驱动调度TD），下面这三种调度算法逐一介绍。

1.1

/>基于优先级的调度算法，基于优先级的调度算法，每个进程被分配一个优先级，每次的进程调度程序，调度程序总是具有最高的调度优先级的任务执行。根据不同的优先级分配方法，基于优先级的调度算法可以分为以下两种类型的Krishna01] [Wang99]：静态优先级调度算法

该算法得到这些系统中运行的所有进程都静态分配一个优先级。静态优先级分配的属性的应用程序，如任务循环中的用户优先级，或其他预先确定的政策。 RM（速率单调）的调度算法是一个典型的静态优先级的调度算法，根据执行的任务的调度优先级的周期的长度确定，那些具有小的执行周期的任务的优先级较高。

动态优先级调度算法：

该算法基于任务的资源需求动态地分配任务的优先级，资源分配和调度的目的更大的灵活性。非实时系统，这种算法有很多，如短作业优先级调度算法。任务的实时调度算法，EDF算法是使用最广泛的动态优先级调度算法，该算法根据他们的截止日期（截止日期）分配优先级的就绪队列中的每个任务，最近期限具有最高的优先级。

1.2

基于优先级调度算法的调度算法是简单而有效的，但这种算法的基础上按比例份额是一个硬实时调度，许多的情况下，不适合使用此算法：例如，软实时应用，如实时多媒体会议系统。对于软实时应用程序，共享资源调度算法（SD算法）的比例使用是更合适的。

比例共享调度算法是指对CPU使用率的比例共享调度算法，其基本思路是按照一定的权重（比率），需要一组调度安排任务，以使它们的权重成比例的执行时间。

要实现比例共享调度算法[Nieh01]有两种方法：第一种方法是调整的准备过程中出现的调度队列队第一频率，并安排一线队的过程中，执行第二种方法是连续调度进程就绪队列中投产，但根据调整分配一个进程的运行时间片分配的权重。

比例共享调度算法可以分为以下类别：循环赛，公平份额，公平排队，的彩票调度方法，（彩票）。

比例共享调度算法的一个问题是，它并没有定义任何优先的概念，所有的任务都根据其应用的CPU资源的比例共享系统过载时，执行的所有任务将较慢比例。因此，为了确保该系统的实时过程中获得一定量的CPU处理时间，一般采用的是动态权重的调整过程。

1.3。基于时间进程调度算法的调度算法

对于那些具有稳定，简单的系统已知输入，您可以使用时间驱动（驱动时间时间：TD）数据处理，它可以提供一个良好的预测。这种调度算法本质上是一个设计定型的离线静态调度方法。在系统的设计阶段，所有处理的情况下，在明确的制度，每个任务切换的开始和结束的时间提前做出了明确的安排和设计。该算法是适用于小型嵌入式系统，自动化控制系统，传感器和其他应用环境。

该算法的优势是良好的可预测性任务的执行，但最大的缺点是缺乏灵活性，而且会有一个任务需要执行，而CPU保持空闲。

一般的Linux系统CPU调度

一般的Linux系统支持实时和非实时两种进程，实时进程与普通进程方面具有绝对的优先权。相应地，实时进程调度策略SCHED_FIFO或SCHED_RR，普通进程SCHED_OTHER调度策略。

每个任务调度算法的实现在Linux四种调度参数，它们是rt_priority优先政策（尼斯），计数器。调度进程调度的基础上，这四个参数。

SCHED_OTHER调度策略，调度程序总是会选择优先级+计数器的值进程调度的执行。从逻辑分析存在SCHED_OTHER调度策略调度处理来执行，其特征在于，所述优先级是一个固定的调度周期（历元），在每个调度周期内的过程中的优先级，计数器的值的大小的影响这一刻已经确定变量值的过程中被创建时，它代表了进程的优先级，也代表数量的时间片，通过该方法可以得到在每个调度周期内，计数器是一个动态值，它反映了当前调度周期的过程中，剩余的时间片。在每个调度周期的开始，分配给优先级值计数器，那么每一次进程被调度运行计数器的值？减少。当计数器的值是零，这个过程已经运行的时间片调度期内，不再参与调度周期进程调度。当所有的进程都用完了时间片调度期结束，然后一遍又一遍。此外，可以看出在Linux系统中的调度周期是不固定的，它的量是动态变化的，例如，在运行的进程的数目和它们的优先级值？可以影响一个划时代的长度。有一点值得注意的是，在2.4内核中，首要任务是不错的替换两个类似的作用。

按比例分担的调度策略调度策略SCHED_OTHER可见的性质，它的这种设计方法，以确保进程调度的公平性 - 一个低优先级进程，在每个时代也将得到他们的份额那些CPU的执行时间，此外，它也提供了不同的进程的优先级，进程执行时间可以得到更多的具有高优先级值。

对于实时的过程中，他们使用基于实时优先级rt_priority的优先级调度策略，但相同的实时优先级的进程调度方法是根据不同的调度策略，

BR /> SCHED_FIFO：不同的进程，根据静态优先级排队，然后在相同的优先级队列，先准备好运行的第一谁调度和运行的进程不会被终止，直到发生以下情况：1。高优先级的进程篡夺了CPU;自己的资源请求受阻;自己主动放弃CPU（呼叫SCHED_YIELD）;

SCHED_RR是这样的：这个调度策略SCHED_FIFO与上述完全相同，除了时间片分配给每个进程，正在实施的过程中，给执行时间片，时间片的长度可以通过sched_rr_get_interval调用

由于Linux系统本身是一个桌面导向的系统，因此，它是用于在实时应用中的一些问题：/> /> Linux系统调度单位是10ms，所以它不能提供精确的定时中断; p>当一个进程调用系统调用进入内核模式运行，它不能被抢占;

Linux内核实现大量采用了封闭中断操作损失;

由于使用虚拟内存技术，当发生页面错误时，从硬盘中读取的数据交换的需要，但硬盘读取和写入的存储位置的随机性，将导致随机读取和写入时间，这在某些情况下，会影响实时任务期限;

虽然Linux的进程调度器还支持实时优先级，但由于缺乏有效的实时任务调度机制和调度算法;其网络子协议处理和其它设备的中断处理，调度伴有相应的过程和自己的有没有明确的调度机制;

各种实时Linux系统
Home>的的

3.1 RT-Linux和RTAI

RT-Linux是新墨西哥大学的研究（新墨西哥州技术学院）[RTLinuxWeb] [Barabanov97。其基本思路是，在Linux系统上的硬实时支持，它实现了一个微内核实时操作系统（也被称为RT-Linux的实时子系统），而普通的Linux系统作为一个低优先级任务在操作系统中运行。在正常的Linux系统的另一个任务可以沟通，通过FIFO和实时任务。 RT-Linux的框架如图1所示：

图1 RT-Linux的结构

RT-Linux的关键技术是软件模拟硬件中断控制器。当Linux系统不时阻止CPU中断，实时定量RT-Linux的子系统的请求拦截，爱不释手，而事实上并没有真正阻止硬件中断，从而避免了由于中断造成的封由系统在一段时间内没有响应，从而在改进的实时。当传递给Linux内核的RT-Linux的一个硬件中断到达截取的中断，并确定是否有一个实时子系统中断例程来处理或处理。此外，的最小定时的精度在正常的Linux系统是确定系统的实时时钟的频率，Linux的系统时钟被设置到时钟中断每秒100，所以在Linux的系统定时的精度10毫秒，即时钟周期10ms时，RT-Linux的实时时钟设置为单触发状态，可以提供更多的十几微秒调度粒度。

RT-Linux实时子系统的任务调度优先级驱动算法，RM，EDF等，也可用于其他调度算法。

RT-Linux的专有系统，重型工作，的确是一个不错的选择，但他只提供了CPU资源的调度和实时系统和Linux系统的关系不是非常密切，因此开发人员可以充分利用已在Linux系统中，如协议栈实现的功能。 RT-Linux的工业控制等实时任务简单和硬实时要求的环境，但大量的工作需要做，如果你想应用的多媒体处理。

意大利实时应用程序接口（RTAI）来自RT-Linux的，它是在设计和RT-Linux的思想相同。这是原来的设计中，为了解决问题，RT-Linux的不同版本的Linux之间很难很难移植，RTAI在Linux上定义的实时硬件抽象层，这个抽象层接口提供实时任务Linux系统的相互作用，这可以增加一点可以Linux内核源代码到Linux内核的实时支持。

3.2。 KURT-Linux的

KURT-Linux的堪萨斯大学开发的，它可以提供实时微秒精度[KurtWeb] [斯里尼瓦桑]。与RT-Linux的单独实现一个实时内核，KURT-Linux是常用的Linux系统的基础上实现的，这也是第一个基于Linux的实时系统可以使用普通的Linux系统调用。

KURT-Linux系统分为三种状态：正常状态，实时状态和混合状态，在正常状态下，它使用普通的Linux实时运行状态实时调度策略任务，实时和非实时任务的混合状态，可以执行实时状态可以被用来为实时的要求更加严格。

为了提高Linux系统的实时特性，有必要提高精度的时钟系统的支持。但是，如果只是简单地增加时钟频率将导致调度负载的增加，从而严重降低系统的性能。为了解决这个矛盾，KURT-Linux中使用的时钟精度的方法[UTIMEWeb]提高Linux系统UTIME，时钟芯片设置为单次触发状态（单拍模式），也就是每个时钟芯片设置超时，然后再次超时事件发生时，在时钟中断的处理程序所需的时钟芯片设置一个超时。其基本思想是一个精确的时间意味着我们需要的时钟中断发生时，我们需要一个更精确的时间，以达到这样的精度，但并不一定需要系统时钟频率。它采用了CPU时钟计数器时间戳计数器（TSC）提供准确的CPU频率精度的时间。

KURT-Linux的实时任务调度，使用静态CPU的实时调度算法，基于时间（TD）。实时任务需要实时事件发生在设计阶段就必须清楚列明。该算法可以实现更好的调度任务，对于那些谁周期。

KURT-Linux的相RT-Linux的优势之一是，你可以使用系统调用的Linux系统，它最初是专为硬实时支持，但因为它是简单的实现将使用一个简单的时间驱动调度取代Linux的调度，实时进程调度的影响等非实时任务，在某些情况下会发生实时任务的截止日期是脆弱的不符合的，也被称为严格的实时系统（快地实时）。基于KURT-Linux的应用程序：艺术（ATM参考交通系统），多媒体播放软件。 KURT-Linux的另一种方法，需要频繁的时钟芯片编程。

3.3。 RED-Linux的

RED-Linux是加州大学尔湾，实时Linux系统的发展[REDWeb] [Wang99]，它将支持实时调度和Linux实现相同的操作系统内核。它支持三种类型的调度算法，即：时间驱动优先Dirven，分享驱动。

为了提高系统的调度粒度，RED-Linux的学习RT-Linux的软件模拟中断的管理机制，并增加频率的时钟中断。 RED-Linux的中断仿真程序只是简单地中断会在队列中排队一个硬件中断到来时，并没有进行实际的中断处理程序。

另外，为了解决Linux的内核模式的过程中不能被中断，RED-Linux的插入Linux内核抢占点原语的众多功能，使这一进程在内核模式下，也在一定程度上被抢占。通过这种方法提高了内核的实时特性。

RED-Linux的设计目标是提供常规调度框架可以支持多种调度算法，系统为每个任务增加几个属性，进程调度的基础上：

优先级：作业的优先级;

开始时间：工作的开始时间;

完成时间：工作的结束时间; BR p>预算：资源的数量在操作过程中要使用的工作;

调整值？这些属性和调度根据什么优先使用的这些属性值几乎所有的调度算法。在这种情况下，三种不同的调度算法无缝地一起耦合到一个统一的。

2. Linux采用了哪几种调度方法各用于哪类进程的调度

你问的是进程调度吧
Linux进程调度采用的是抢占式多任务处理，所以进程之间的挂起和继续运行无需彼此之间的协作。
调度方式：时间片，优先级，还有就是时间片加优先级混合，默认是第三种

3. 现在的多核CPU，Linux操作系统是否能够实现单个进程（多线程）的多核调度（跨CPU核心调度）

现在的技术，还是一个线程只能运行在一个 CPU 上。多核心，必须用多线程/进程来运行才能实现最大化。当然，你可以单个线程不停的在所有的 CPU 上来回跳。但是效率会很低很低。
因为 CPU 有寄存器和缓存的问题。如果你切换 CPU 运行，所有的数据都要进行一次传递。非常浪费时钟（在 CPU 上，程序执行不是一个时钟马上就能任意执行一个指令，而是流水线作业，一个指令需要很多个时钟才能处理完，数据存取也都要等）。

这也因为程序原本就都是顺序执行的。你没办法让一个程序的后面的结果可以跳过前面的结果而得出。
当然，现在 CPU 确实有这种技术，叫做乱序执行。也就是当前面的过程还没有计算时，后面的指令先计算。但是这种事情是要靠猜测的，而且这也仅仅是分支预测，依然不能预测某个计算的结果。即便猜的再准确，也有错的时候。奔腾4 最老的版本就有这个问题，流水线太长。计算后发现错了。整条流水线需要清空重新计算。有严重性能问题的奔腾4 CPU ，流水线长度是 31 级。也就是一个程序至少 31 个时钟周期才能从推到流水线后到真正执行。直接浪费了 31 个时钟周期。

所以目前的技术来说，单线程多核新协同计算，技术上不可能实现。
提高性能，就是整理数据处理的算法，把多次重复计算的过程，拆成多条线程分别计算。从而保证 CPU 多核新的效率最大化。每个线程可以共享同一块数据，自己读取自己的数据计算使可以的。不过，这时候就有另外一个问题，数据寻址和传递的性能问题。

4. linux下怎么查看cpu的调度

检查cpu频率的方法如下；

查看 /proc/cpuinfo ，这个虚拟文件展示的是可用CPU硬件的配置。

通过查看这个文件，你能识别出物理处理器数（插槽），每个CPU核心数，可用的CPU标志寄存器以及其它东西的数量。

cpuid命令的功能就相当于一个专用的CPU信息工具，它能通过使用CPUID功能来显示详细的关于CPU硬件的信息。

信息报告包括处理器类型/家族、CPU扩展指令集、缓存/TLB（译者注：传输后备缓冲器）配置、电源管理功能等等。

网页链接由于电脑代码复杂，具体配图可参考此链接。

Linux是一套免费使用和自由传播的类Unix操作系统，是一个基于POSIX和UNIX的多用户，多任务，支持多线程和多CPU的操作系统。它能运行主要的UNIX工具软件，应用程序和网络协议。它支持32位和64位硬件。Linux继承了Unix以网络为核心的设计思想，是一个性能稳定的多用户网络操作系统。

5. linux内核怎么调度系统

1.调度器的概述

多任务操作系统分为非抢占式多任务和抢占式多任务。与大多数现代操作系统一样，Linux采用的是抢占式多任务模式。这表示对CPU的占用时间由操作系统决定的，具体为操作系统中的调度器。调度器决定了什么时候停止一个进程以便让其他进程有机会运行，同时挑选出一个其他的进程开始运行。

2.调度策略

在Linux上调度策略决定了调度器是如何选择一个新进程的时间。调度策略与进程的类型有关，内核现有的调度策略如下：

#define SCHED_NORMAL 0#define SCHED_FIFO 1#define SCHED_RR 2#define SCHED_BATCH 3/* SCHED_ISO: reserved but not implemented yet */#define SCHED_IDLE 5

0: 默认的调度策略，针对的是普通进程。
1：针对实时进程的先进先出调度。适合对时间性要求比较高但每次运行时间比较短的进程。
2：针对的是实时进程的时间片轮转调度。适合每次运行时间比较长得进程。
3：针对批处理进程的调度，适合那些非交互性且对cpu使用密集的进程。
SCHED_ISO：是内核的一个预留字段，目前还没有使用
5：适用于优先级较低的后台进程。
注：每个进程的调度策略保存在进程描述符task_struct中的policy字段

3.调度器中的机制

内核引入调度类（struct sched_class）说明了调度器应该具有哪些功能。内核中每种调度策略都有该调度类的一个实例。（比如：基于公平调度类为：fair_sched_class，基于实时进程的调度类实例为：rt_sched_class），该实例也是针对每种调度策略的具体实现。调度类封装了不同调度策略的具体实现，屏蔽了各种调度策略的细节实现。
调度器核心函数schele()只需要调用调度类中的接口，完成进程的调度，完全不需要考虑调度策略的具体实现。调度类连接了调度函数和具体的调度策略。

• 武特师兄关于sche_class和sche_entity的解释，一语中的。

• 调度类就是代表的各种调度策略，调度实体就是调度单位，这个实体通常是一个进程，但是自从引入了cgroup后，这个调度实体可能就不是一个进程了，而是一个组

4.schele()函数

linux 支持两种类型的进程调度，实时进程和普通进程。实时进程采用SCHED_FIFO 和SCHED_RR调度策略，普通进程采用SCHED_NORMAL策略。
preempt_disable()：禁止内核抢占
cpu_rq（）：获取当前cpu对应的就绪队列。
prev = rq->curr;获取当前进程的描述符prev
switch_count = &prev->nivcsw;获取当前进程的切换次数。
update_rq_clock() ：更新就绪队列上的时钟
clear_tsk_need_resched()清楚当前进程prev的重新调度标志。
deactive_task():将当前进程从就绪队列中删除。
put_prev_task() :将当前进程重新放入就绪队列
pick_next_task():在就绪队列中挑选下一个将被执行的进程。
context_switch():进行prev和next两个进程的切换。具体的切换代码与体系架构有关，在switch_to()中通过一段汇编代码实现。
post_schele():进行进程切换后的后期处理工作。

5.pick_next_task函数

选择下一个将要被执行的进程无疑是一个很重要的过程，我们来看一下内核中代码的实现
对以下这段代码说明：
1.当rq中的运行队列的个数(nr_running)和cfs中的nr_runing相等的时候，表示现在所有的都是普通进程，这时候就会调用cfs算法中的pick_next_task(其实是pick_next_task_fair函数)，当不相等的时候，则调用sched_class_highest(这是一个宏，指向的是实时进程)，这下面的这个for(;;)循环中，首先是会在实时进程中选取要调度的程序（p = class->pick_next_task(rq);）。如果没有选取到，会执行class=class->next;在class这个链表中有三种类型（fair,idle,rt）.也就是说会调用到下一个调度类。

• static inline struct task_struct *pick_next_task(struct rq *rq){ const struct sched_class *class; struct task_struct *p; /*


• * Optimization: we know that if all tasks are in


• * the fair class we can call that function directly:


• *///基于公平调度的普通进程


• if (likely(rq->nr_running == rq->cfs.nr_running)) {


• p = fair_sched_class.pick_next_task(rq); if (likely(p)) return p;


• }//基于实时调度的实时进程


• class = sched_class_highest; for ( ; ; ) {


• p = class->pick_next_task(rq); //实时进程的类


• if (p) return p; /*


• * Will never be NULL as the idle class always


• * returns a non-NULL p:


• */


• class = class->next; //rt->next = fair; fair->next = idle


• }


• }



在这段代码中体现了Linux所支持的两种类型的进程，实时进程和普通进程。回顾下：实时进程可以采用SCHED_FIFO 和SCHED_RR调度策略，普通进程采用SCHED_NORMAL调度策略。
在这里首先说明一个结构体struct rq,这个结构体是调度器管理可运行状态进程的最主要的数据结构。每个cpu上都有一个可运行的就绪队列。刚才在pick_next_task函数中看到了在选择下一个将要被执行的进程时实际上用的是struct rq上的普通进程的调度或者实时进程的调度，那么具体是如何调度的呢？在实时调度中，为了实现O(1)的调度算法，内核为每个优先级维护一个运行队列和一个DECLARE_BITMAP,内核根据DECLARE_BITMAP的bit数值找出非空的最高级优先队列的编号，从而可以从非空的最高级优先队列中取出进程进行运行。
我们来看下内核的实现

• struct rt_prio_array {


• DECLARE_BITMAP(bitmap, MAX_RT_PRIO+1); /* include 1 bit for delimiter */


• struct list_head queue[MAX_RT_PRIO];


• };



数组queue[i]里面存放的是优先级为i的进程队列的链表头。在结构体rt_prio_array 中有一个重要的数据构DECLARE_BITMAP，它在内核中的第一如下：

• define DECLARE_BITMAP(name,bits)


• unsigned long name[BITS_TO_LONGS(bits)]



5.1对于实时进程的O(1)算法

这个数据是用来作为进程队列queue[MAX_PRIO]的索引位图。bitmap中的每一位与queue[i]对应，当queue[i]的进程队列不为空时，Bitmap的相应位就为1，否则为0，这样就只需要通过汇编指令从进程优先级由高到低的方向找到第一个为1的位置，则这个位置就是就绪队列中最高的优先级（函数sched_find_first_bit()就是用来实现该目的的）。那么queue[index]->next就是要找的候选进程。
如果还是不懂，那就来看两个图


由结果可以看出当nice的值越小的时候，其睡眠时间越短，则表示其优先级升高了。

7.关于获取和设置优先级的系统调用：sched_getscheler（）和sched_setscheler

• #include <sched.h>#include <stdlib.h>#include <stdio.h>#include <errno.h>#define DEATH(mess) { perror(mess); exit(errno); }void printpolicy (int policy){ /* SCHED_NORMAL = SCHED_OTHER in user-space */



• if (policy == SCHED_OTHER) printf ("policy = SCHED_OTHER = %d ", policy); if (policy == SCHED_FIFO) printf ("policy = SCHED_FIFO = %d ", policy); if (policy == SCHED_RR) printf ("policy = SCHED_RR = %d ", policy);


• }int main (int argc, char **argv){ int policy; struct sched_param p; /* obtain current scheling policy for this process */


• //获取进程调度的策略


• policy = sched_getscheler (0);


• printpolicy (policy); /* reset scheling policy */



• printf (" Trying sched_setscheler... ");


• policy = SCHED_FIFO;


• printpolicy (policy);


• p.sched_priority = 50; //设置优先级为50


• if (sched_setscheler (0, policy, &p))


• DEATH ("sched_setscheler:"); printf ("p.sched_priority = %d ", p.sched_priority); exit (0);


• }



输出结果：

• [root@wang schele]# ./get_schele_policy policy = SCHED_OTHER = 0



• Trying sched_setscheler...


• policy = SCHED_FIFO = 1


• p.sched_priority = 50



可以看出进程的优先级已经被改变。

6. linux 调整CPU程序调度的几种方法

一，使用taskset充分利用多核cpu，让cpu的使用率均衡到每个cpu上
#taskset
-p, 设定一个已存在的pid，而不是重新开启一个新任务
-c, 指定一个处理，可以指定多个，以逗号分隔，也可指定范围，如：2,4,5,6-8。
1，切换某个进程到指定的cpu上
taskset -cp 3 13290
2，让某程序运行在指定的cpu上
taskset -c 1,2,4-7 tar jcf test.tar.gz test
需要注意的是，taskset -cp 3 13290在设定一个已经存在的pid时，子进程并不会继承父进程的，
因此像tar zcf xxx.tar.gz xxx这样的命令，最好在启动时指定cpu，如果在已经启动的情况下，则需要指定tar调用的gzip进程。
二，使用nice和renice设置程序执行的优先级
格式：nice [-n 数值] 命令
nice 指令可以改变程序执行的优先权等级。指令让使用者在执行程序时，指定一个优先等级，称之为 nice 值。
这个数值从最高优先级的-20到最低优先级的19。负数值只有 root 才有权力使。
一般使用者，也可使用 nice 指令来做执行程序的优先级管理，但只能将nice值越调越高。
可以通过二种方式来给某个程序设定nice值：
1，开始执行程序时给定一个nice值，用nice命令
2，调整某个运行中程序的PID的nice值，用renice命令
通常通过调高nice值来备份，为的是不占用非常多的系统资源。
例：
nice -n 10 tar zcf test.tar.gz test
由nice启动的程序，其子进程会继承父进程的nice值。
查看nice值
# nice -n -6 vim test.txt &
# ps -l
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
4 S 0 19427 2637 0 75 0 – 16551 wait pts/6 00:00:00 bash
4 T 0 21654 19427 0 71 -6 – 23464 finish pts/6 00:00:00 vim
renice调整运行中程序的nice值
格式：renice [nice值] PID
三，使用ulimit限制cpu占用时间
注意，ulimit 限制的是当前shell进程以及其派生的子进程。因此可以在脚本中调用ulimit来限制cpu使用时间。
例如，限制tar的cpu占用时间，单位秒。
# cat limit_cpu.sh
ulimit -SHt 100
tar test.tar.gz test
如果tar占用时间超过了100秒，tar将会退出，这可能会导致打包不完全，因此不推荐使用ulimit对cpu占用时间进行限制。
另外，通过修改系统的/etc/security/limits配置文件，可以针对用户进行限制。
四，使用程序自带的对cpu使用调整的功能
某些程序自带了对cpu使用调整的功能，比如nginx服务器，通过其配置文件，可以为工作进程指定cpu，如下：
worker_processes 3;
worker_cpu_affinity 0001 0010 0100 1000;
这里0001 0010 0100 1000是掩码，分别代表第1、2、3、4颗cpu核心，这就使得cpu的使用比较平均到每个核心上。

7. linux系统性能怎么优化

linux系统性能怎么优化
一、前提
我们可以在文章的开始就列出一个列表，列出可能影响Linux操作系统性能的一些调优参数，但这样做其实并没有什么价值。因为性能调优是一个非常困难的任务，它要求对硬件、操作系统、和应用都有着相当深入的了解。如果性能调优非常简单的话，那些我们要列出的调优参数早就写入硬件的微码或者操作系统中了，我们就没有必要再继续读这篇文章了。正如下图所示，服务器的性能受到很多因素的影响。
当面对一个使用单独IDE硬盘的，有20000用户的数据库服务器时，即使我们使用数周时间去调整I/O子系统也是徒劳无功的，通常一个新的驱动或者应用程序的一个更新(如SQL优化)却可以使这个服务器的性能得到明显的提升。正如我们前面提到的，不要忘记系统的性能是受多方面因素影响的。理解操作系统管理系统资源的方法将帮助我们在面对问题时更好的判断应该对哪个子系统进行调整。
二、Linux的CPU调度
任何计算机的基本功能都十分简单，那就是计算。为了实现计算的功能就必须有一个方法去管理计算资源、处理器和计算任务(也被叫做线程或者进程)。非常感谢Ingo Molnar，他为Linux内核带来了O(1)CPU调度器，区别于旧有的O(n)调度器，新的调度器是动态的，可以支持负载均衡，并以恒定的速度进行操作。
新调度器的可扩展性非常好，无论进程数量或者处理器数量，并且调度器本身的系统开销更少。新调取器的算法使用两个优先级队列。
引用
・活动运行队列
・过期运行队列
调度器的一个重要目标是根据优先级权限有效地为进程分配CPU 时间片，当分配完成后它被列在CPU的运行队列中，除了 CPU 的运行队列之外，还有一个过期运行队列。当活动运行队列中的一个任务用光自己的时间片之后，它就被移动到过期运行队列中。在移动过程中，会对其时间片重新进行计算。如果活动运行队列中已经没有某个给定优先级的任务了，那么指向活动运行队列和过期运行队列的指针就会交换，这样就可以让过期优先级列表变成活动优先级的列表。通常交互式进程(相对与实时进程而言)都有一个较高的优先级，它占有更长的时间片，比低优先级的进程获得更多的计算时间，但通过调度器自身的调整并不会使低优先级的进程完全被饿死。新调度器的优势是显着的改变Linux内核的可扩展性，使新内核可以更好的处理一些有大量进程、大量处理器组成的企业级应用。新的O(1)调度器包含仔2.6内核中，但是也向下兼容2.4内核。
新调度器另外一个重要的优势是体现在对NUMA(non-uniform memory architecture)和SMP(symmetric multithreading processors)的支持上，例如INTEL@的超线程技术。
改进的NUMA支持保证了负载均衡不会发生在CECs或者NUMA节点之间，除非发生一个节点的超出负载限度。
三、Linux的内存架构
今天我们面对选择32位操作系统还是64位操作系统的情况。对企业级用户它们之间最大的区别是64位操作系统可以支持大于4GB的内存寻址。从性能角度来讲，我们需要了解32位和64位操作系统都是如何进行物理内存和虚拟内存的映射的。
在上面图示中我们可以看到64位和32位Linux内核在寻址上有着显着的不同。
在32位架构中，比如IA-32，Linux内核可以直接寻址的范围只有物理内存的第一个GB(如果去掉保留部分还剩下896MB)，访问内存必须被映射到这小于1GB的所谓ZONE_NORMAL空间中，这个操作是由应用程序完成的。但是分配在ZONE_HIGHMEM中的内存页将导致性能的降低。
在另一方面，64位架构比如x86-64(也称作EM64T或者AMD64)。ZONE_NORMAL空间将扩展到64GB或者128GB(实际上可以更多，但是这个数值受到操作系统本身支持内存容量的限制)。正如我们看到的，使用64位操作系统我们排除了因ZONE_HIGHMEM部分内存对性能的影响的情况。
实际中，在32位架构下，由于上面所描述的内存寻址问题，对于大内存，高负载应用，会导致死机或严重缓慢等问题。虽然使用hugemen核心可缓解，但采取x86_64架构是最佳的解决办法。
四、虚拟内存管理
因为操作系统将内存都映射为虚拟内存，所以操作系统的物理内存结构对用户和应用来说通常都是不可见的。如果想要理解Linux系统内存的调优，我们必须了解Linux的虚拟内存机制。应用程序并不分配物理内存，而是向Linux内核请求一部分映射为虚拟内存的内存空间。如下图所示虚拟内存并不一定是映射物理内存中的空间，如果应用程序有一个大容量的请求，也可能会被映射到在磁盘子系统中的swap空间中。
另外要提到的是，通常应用程序不直接将数据写到磁盘子系统中，而是写入缓存和缓冲区中。Bdflush守护进程将定时将缓存或者缓冲区中的数据写到硬盘上。
Linux内核处理数据写入磁盘子系统和管理磁盘缓存是紧密联系在一起的。相对于其他的操作系统都是在内存中分配指定的一部分作为磁盘缓存，Linux处理内存更加有效，默认情况下虚拟内存管理器分配所有可用内存空间作为磁盘缓存，这就是为什么有时我们观察一个配置有数G内存的Linux系统可用内存只有20MB的原因。
同时Linux使用swap空间的机制也是相当高效率的，如上图所示虚拟内存空间是由物理内存和磁盘子系统中的swap空间共同组成的。如果虚拟内存管理器发现一个已经分配完成的内存分页已经长时间没有被调用，它将把这部分内存分页移到swap空间中。经常我们会发现一些守护进程，比如getty，会随系统启动但是却很少会被应用到。这时为了释放昂贵的主内存资源，系统会将这部分内存分页移动到swap空间中。上述就是Linux使用swap空间的机制，当swap分区使用超过50%时，并不意味着物理内存的使用已经达到瓶颈了，swap空间只是Linux内核更好的使用系统资源的一种方法。
简单理解：Swap usage只表示了Linux管理内存的有效性。对识别内存瓶颈来说，Swap In/Out才是一个比较又意义的依据，如果Swap In/Out的值长期保持在每秒200到300个页面通常就表示系统可能存在内存的瓶颈。下面的事例是好的状态：
引用
# vmstat
procs ———–memory————- —swap– —–io—- –system– —-cpu—-
r b swpd free buff cache si so bi bo in cs us sy id wa
1 0 5696 6904 28192 50496 0 0 88 117 61 29 11 8 80 1
五、模块化的I/O调度器
就象我们知道的Linux2.6内核为我们带来了很多新的特性，这其中就包括了新的I/O调度机制。旧的2.4内核使用一个单一的I/O调度器，2.6 内核为我们提供了四个可选择的I/O调度器。因为Linux系统应用在很广阔的范围里，不同的应用对I/O设备和负载的要求都不相同，例如一个笔记本电脑和一个10000用户的数据库服务器对I/O的要求肯定有着很大的区别。
引用
(1).Anticipatory
anticipatory I/O调度器创建假设一个块设备只有一个物理的查找磁头(例如一个单独的SATA硬盘)，正如anticipatory调度器名字一样，anticipatory调度器使用“anticipatory”的算法写入硬盘一个比较大的数据流代替写入多个随机的小的数据流，这样有可能导致写 I/O操作的一些延时。这个调度器适用于通常的一些应用，比如大部分的个人电脑。
(2).Complete Fair Queuing (CFQ)
Complete Fair Queuing(CFQ)调度器是Red Flag DC Server 5使用的标准算法。CFQ调度器使用QoS策略为系统内的所有任务分配相同的带宽。CFQ调度器适用于有大量计算进程的多用户系统。它试图避免进程被饿死和实现了比较低的延迟。
(3).Deadline
deadline调度器是使用deadline算法的轮询的调度器，提供对I/O子系统接近实时的操作，deadline调度器提供了很小的延迟和维持一个很好的磁盘吞吐量。如果使用deadline算法请确保进程资源分配不会出现问题。
(4).NOOP
NOOP调度器是一个简化的调度程序它只作最基本的合并与排序。与桌面系统的关系不是很大，主要用在一些特殊的软件与硬件环境下，这些软件与硬件一般都拥有自己的调度机制对内核支持的要求很小，这很适合一些嵌入式系统环境。作为桌面用户我们一般不会选择它。
六、网络子系统
新的网络中断缓和(NAPI)对网络子系统带来了改变，提高了大流量网络的性能。Linux内核在处理网络堆栈时，相比降低系统占用率和高吞吐量更关注可靠性和低延迟。所以在某些情况下，Linux建立一个防火墙或者文件、打印、数据库等企业级应用的性能可能会低于相同配置的Windows服务器。
在传统的处理网络封包的方式中，如下图蓝色箭头所描述的，一个以太网封包到达网卡接口后，如果MAC地址相符合会被送到网卡的缓冲区中。网卡然后将封包移到操作系统内核的网络缓冲区中并且对CPU发出一个硬中断，CPU会处理这个封包到相应的网络堆栈中，可能是一个TCP端口或者Apache应用中。
这是一个处理网络封包的简单的流程，但从中我们可以看到这个处理方式的缺点。正如我们看到的，每次适合网络封包到达网络接口都将对CPU发出一个硬中断信号，中断CPU正在处理的其他任务，导致切换动作和对CPU缓存的操作。你可能认为当只有少量的网络封包到达网卡的情况下这并不是个问题，但是千兆网络和现代的应用将带来每秒钟成千上万的网络数据，这就有可能对性能造成不良的影响。
正是因为这个情况，NAPI在处理网络通讯的时候引入了计数机制。对第一个封包，NAPI以传统的方式进行处理，但是对后面的封包，网卡引入了POLL 的轮询机制：如果一个封包在网卡DMA环的缓存中，就不再为这个封包申请新的中断，直到最后一个封包被处理或者缓冲区被耗尽。这样就有效的减少了因为过多的中断CPU对系统性能的影响。同时，NAPI通过创建可以被多处理器执行的软中断改善了系统的可扩展性。NAPI将为大量的企业级多处理器平台带来帮助，它要求一个启用NAPI的驱动程序。在今天很多驱动程序默认没有启用NAPI，这就为我们调优网络子系统的性能提供了更广阔的空间。
七、理解Linux调优参数
因为Linux是一个开源操作系统，所以又大量可用的性能监测工具。对这些工具的选择取决于你的个人喜好和对数据细节的要求。所有的性能监测工具都是按照同样的规则来工作的，所以无论你使用哪种监测工具都需要理解这些参数。下面列出了一些重要的参数，有效的理解它们是很有用处的。
(1)处理器参数
引用
・CPU utilization
这是一个很简单的参数，它直观的描述了每个CPU的利用率。在xSeries架构中，如果CPU的利用率长时间的超过80%，就可能是出现了处理器的瓶颈。
・Runable processes
这个值描述了正在准备被执行的进程，在一个持续时间里这个值不应该超过物理CPU数量的10倍，否则CPU方面就可能存在瓶颈。
・Blocked
描述了那些因为等待I/O操作结束而不能被执行的进程，Blocked可能指出你正面临I/O瓶颈。
・User time
描述了处理用户进程的百分比，包括nice time。如果User time的值很高，说明系统性能用在处理实际的工作。
・System time
描述了CPU花费在处理内核操作包括IRQ和软件中断上面的百分比。如果system time很高说明系统可能存在网络或者驱动堆栈方面的瓶颈。一个系统通常只花费很少的时间去处理内核的操作。
・Idle time
描述了CPU空闲的百分比。
・Nice time
描述了CPU花费在处理re-nicing进程的百分比。
・Context switch
系统中线程之间进行交换的数量。
・Waiting
CPU花费在等待I/O操作上的总时间，与blocked相似，一个系统不应该花费太多的时间在等待I/O操作上，否则你应该进一步检测I/O子系统是否存在瓶颈。
・Interrupts
Interrupts 值包括硬Interrupts和软Interrupts，硬Interrupts会对系统性能带来更多的不利影响。高的Interrupts值指出系统可能存在一个软件的瓶颈，可能是内核或者驱动程序。注意Interrupts值中包括CPU时钟导致的中断(现代的xServer系统每秒1000个 Interrupts值)。
(2)内存参数
引用
・Free memory
相比其他操作系统，Linux空闲内存的值不应该做为一个性能参考的重要指标，因为就像我们之前提到过的，Linux内核会分配大量没有被使用的内存作为文件系统的缓存，所以这个值通常都比较小。
・Swap usage
这 个值描述了已经被使用的swap空间。Swap usage只表示了Linux管理内存的有效性。对识别内存瓶颈来说，Swap In/Out才是一个比较又意义的依据，如果Swap In/Out的值长期保持在每秒200到300个页面通常就表示系统可能存在内存的瓶颈。
・Buffer and cache
这个值描述了为文件系统和块设备分配的缓存。在Red Flag DC Server 5版本中,你可以通过修改/proc/sys/vm中的page_cache_tuning来调整空闲内存中作为缓存的数量。
・Slabs
描述了内核使用的内存空间，注意内核的页面是不能被交换到磁盘上的。
・Active versus inactive memory
提供了关于系统内存的active内存信息，Inactive内存是被kswapd守护进程交换到磁盘上的空间。
(3)网络参数
引用
・Packets received and sent
这个参数表示了一个指定网卡接收和发送的数据包的数量。
・Bytes received and sent
这个参数表示了一个指定网卡接收和发送的数据包的字节数。
・Collisions per second
这个值提供了发生在指定网卡上的网络冲突的数量。持续的出现这个值代表在网络架构上出现了瓶颈，而不是在服务器端出现的问题。在正常配置的网络中冲突是非常少见的，除非用户的网络环境都是由hub组成。
・Packets dropped
这个值表示了被内核丢掉的数据包数量，可能是因为防火墙或者是网络缓存的缺乏。
・Overruns
Overruns表达了超出网络接口缓存的次数，这个参数应该和packets dropped值联系到一起来判断是否存在在网络缓存或者网络队列过长方面的瓶颈。
・Errors 这个值记录了标志为失败的帧的数量。这个可能由错误的网络配置或者部分网线损坏导致，在铜口千兆以太网环境中部分网线的损害是影响性能的一个重要因素。
(4)块设备参数
引用
・Iowait
CPU等待I/O操作所花费的时间。这个值持续很高通常可能是I/O瓶颈所导致的。
・Average queue length
I/O请求的数量，通常一个磁盘队列值为2到3为最佳情况，更高的值说明系统可能存在I/O瓶颈。
・Average wait
响应一个I/O操作的平均时间。Average wait包括实际I/O操作的时间和在I/O队列里等待的时间。
・Transfers per second
描述每秒执行多少次I/O操作(包括读和写)。Transfers per second的值与kBytes per second结合起来可以帮助你估计系统的平均传输块大小，这个传输块大小通常和磁盘子系统的条带化大小相符合可以获得最好的性能。
・Blocks read/write per second
这个值表达了每秒读写的blocks数量，在2.6内核中blocks是1024bytes，在早些的内核版本中blocks可以是不同的大小，从512bytes到4kb。
・Kilobytes per second read/write
按照kb为单位表示读写块设备的实际数据的数量。

8. linux进程调度的三种策略是什么

进程调度策略就是调度系统种哪一个进程来CPU运行。这种调度分2层考虑。 第一层，进程状态这个是最优先考虑的，也就是说优先级最高的。在linux中只有就绪态的进程才有可能会被调度选中然后占有CPU，其它状态的进程不可能占有的到CPU。下面是linux中进程的状态TASK_RUNNING:就绪状态，得到CPU就可以运行。
TASK_INTERRUPTIBLE:浅度睡眠，资源到位或者受到信号就会变成就绪态。
TASK_UNINTERRUPTIBLE:深度睡眠，资源到位就会进入就绪态，不响应信号。
TASK_ZOMBIE：僵死态，进程exit后。
TASK_STOPPED：暂停态，收到SIG_CONT信号进入就绪态。 第二层，其实真正在操作系统中的实现，就是所有就绪态进程链接成一个队列，进程调度时候只会考虑这个队列中的进程，对其它的进程不考虑，这就实现了第一层中的要求。接下来就是就绪队列内部各个进程的竞争了。 Linux采用3种不同的调度政策，SCHED_FIFO（下面简写成FIFO，先来先服务），SCHED_RR（简写成RR，时间片轮流），SCHED_OTHER（下面简写成OTHER）。这里大家就能看出一个问题，采用同等调度政策的进程之间自然有可比性，Linux3种调度政策并存，那么不同调度政策间的进程如何比较呢？可以说他们之间根本就没有可比性。其实在调度时候，调度只看一个指标，那就是各个进程所具有的权值，权值最大的且在可执行队列中排在最前面的就会被调度执行。而权值的计算才会设计到各方面因素，其中调度政策可以说在计算权值中，份量是最重的。 为什么Linux要这么干呢？这是由于事务的多样性决定的，进程有实时性进程和非实时性的进程2种，FIFO和RR是用来支持实时性进程的调度，我们看一下这3种政策下权值的计算公式就明白了：FIFO和RR计算公式，权值=1000+进程真正的运行时间OTHER计算公式，当时间片为0时，权值=0.当时间片不为0时候，权值=剩余时间片+20-nice,同时如果是内核线程有+1的小加分，这是因为内核线程无需用户空间的切换，所以给它加了一分，奖励他在进程切换时候开销小的功劳。时间片好理解，那么nice这个值，用过linux系统的人都知道，这是一个从unix下继承过来的概念，表示谦让度，是一个从20～-19的数，可以通过nice和renice指令来设置。从代码中也能看到值越小就越不会谦让他人。 从这里我们看出FIFO和RR至少有1000的基数，所以在有FIFO和RR调度政策进程存在时，OTHER进程是没有机会被调度的到的。从权值计算公式同时也能看出，FIFO先来先服务的调度政策满足了，但RR这个时间片轮流的调度如果按照这种权值计算是不能满足时间片轮流这一概念的。这里只是权值的计算，在调度时候对RR政策的进程特殊处理。 以上都是权值计算，下面看看真正的调度过程，首先是对RR政策进程的特殊处理，如果当前进程采用的RR政策，那么看他的时间片是否用完，用完了就踢到就绪队列尾部，同时恢复他的时间片。然后是便利整个就绪队列，找到第一个权值最大的进程来运行。 整体调度效果就是：如果有FIFO和RR政策的进程，就优先调度他们2个，他们之间看已执行时间长短决定胜负，而2种政策内部则遵守各自调度政策。而OTHER只有在前面2种不存在于就绪队列时候才有可能执行，他们实际也是轮流执行，但他们之间是靠剩余时间和NICE值来决定胜负。同时就绪队列中排在最前面的最优先考虑在同样权值情况下。

9. linux环境下的进程调度算法有哪些

第一部分： 实时调度算法介绍

对于什么是实时系统，POSIX 1003.b作了这样的定义：指系统能够在限定的响应时间内提供所需水平的服务。而一个由Donald Gillies提出的更加为大家接受的定义是：一个实时系统是指计算的正确性不仅取决于程序的逻辑正确性，也取决于结果产生的时间，如果系统的时间约束条件得不到满足，将会发生系统出错。

实时系统根据其对于实时性要求的不同，可以分为软实时和硬实时两种类型。硬实时系统指系统要有确保的最坏情况下的服务时间，即对于事件的响应时间的截止期限是无论如何都必须得到满足。比如航天中的宇宙飞船的控制等就是现实中这样的系统。其他的所有有实时特性的系统都可以称之为软实时系统。如果明确地来说，软实时系统就是那些从统计的角度来说，一个任务（在下面的论述中，我们将对任务和进程不作区分）能够得到有确保的处理时间，到达系统的事件也能够在截止期限到来之前得到处理，但违反截止期限并不会带来致命的错误，像实时多媒体系统就是一种软实时系统。

一个计算机系统为了提供对于实时性的支持，它的操作系统必须对于CPU和其他资源进行有效的调度和管理。在多任务实时系统中，资源的调度和管理更加复杂。本文下面将先从分类的角度对各种实时任务调度算法进行讨论，然后研究普通的 Linux操作系统的进程调度以及各种实时Linux系统为了支持实时特性对普通Linux系统所做的改进。最后分析了将Linux操作系统应用于实时领域中时所出现的一些问题，并总结了各种实时Linux是如何解决这些问题的。

1. 实时CPU调度算法分类

各种实时操作系统的实时调度算法可以分为如下三种类别[Wang99][Gopalan01]：基于优先级的调度算法（Priority-driven scheling-PD）、基于CPU使用比例的共享式的调度算法（Share-driven scheling-SD）、以及基于时间的进程调度算法（Time-driven scheling-TD），下面对这三种调度算法逐一进行介绍。

1.1. 基于优先级的调度算法

基于优先级的调度算法给每个进程分配一个优先级，在每次进程调度时，调度器总是调度那个具有最高优先级的任务来执行。根据不同的优先级分配方法，基于优先级的调度算法可以分为如下两种类型[Krishna01][Wang99]：

静态优先级调度算法：

这种调度算法给那些系统中得到运行的所有进程都静态地分配一个优先级。静态优先级的分配可以根据应用的属性来进行，比如任务的周期，用户优先级，或者其它的预先确定的策略。RM（Rate-Monotonic）调度算法是一种典型的静态优先级调度算法，它根据任务的执行周期的长短来决定调度优先级，那些具有小的执行周期的任务具有较高的优先级。

动态优先级调度算法：

这种调度算法根据任务的资源需求来动态地分配任务的优先级，其目的就是在资源分配和调度时有更大的灵活性。非实时系统中就有很多这种调度算法，比如短作业优先的调度算法。在实时调度算法中， EDF算法是使用最多的一种动态优先级调度算法，该算法给就绪队列中的各个任务根据它们的截止期限（Deadline）来分配优先级，具有最近的截止期限的任务具有最高的优先级。

1.2. 基于比例共享调度算法

虽然基于优先级的调度算法简单而有效，但这种调度算法提供的是一种硬实时的调度，在很多情况下并不适合使用这种调度算法：比如象实时多媒体会议系统这样的软实时应用。对于这种软实时应用，使用一种比例共享式的资源调度算法（SD算法）更为适合。

比例共享调度算法指基于CPU使用比例的共享式的调度算法，其基本思想就是按照一定的权重（比例）对一组需要调度的任务进行调度，让它们的执行时间与它们的权重完全成正比。

我们可以通过两种方法来实现比例共享调度算法[Nieh01]：第一种方法是调节各个就绪进程出现在调度队列队首的频率，并调度队首的进程执行；第二种做法就是逐次调度就绪队列中的各个进程投入运行，但根据分配的权重调节分配个每个进程的运行时间片。

比例共享调度算法可以分为以下几个类别：轮转法、公平共享、公平队列、彩票调度法（Lottery）等。

比例共享调度算法的一个问题就是它没有定义任何优先级的概念；所有的任务都根据它们申请的比例共享CPU资源，当系统处于过载状态时，所有的任务的执行都会按比例地变慢。所以为了保证系统中实时进程能够获得一定的CPU处理时间，一般采用一种动态调节进程权重的方法。

1.3. 基于时间的进程调度算法

对于那些具有稳定、已知输入的简单系统，可以使用时间驱动（Time-driven:TD）的调度算法，它能够为数据处理提供很好的预测性。这种调度算法本质上是一种设计时就确定下来的离线的静态调度方法。在系统的设计阶段，在明确系统中所有的处理情况下，对于各个任务的开始、切换、以及结束时间等就事先做出明确的安排和设计。这种调度算法适合于那些很小的嵌入式系统、自控系统、传感器等应用环境。

这种调度算法的优点是任务的执行有很好的可预测性，但最大的缺点是缺乏灵活性，并且会出现有任务需要被执行而CPU却保持空闲的情况。

2. 通用Linux系统中的CPU调度

通用Linux系统支持实时和非实时两种进程，实时进程相对于普通进程具有绝对的优先级。对应地，实时进程采用SCHED_FIFO或者SCHED_RR调度策略，普通的进程采用SCHED_OTHER调度策略。

在调度算法的实现上，Linux中的每个任务有四个与调度相关的参数，它们是rt_priority、policy、priority（nice）、counter。调度程序根据这四个参数进行进程调度。

在SCHED_OTHER 调度策略中，调度器总是选择那个priority+counter值最大的进程来调度执行。从逻辑上分析，SCHED_OTHER调度策略存在着调度周期（epoch），在每一个调度周期中，一个进程的priority和counter值的大小影响了当前时刻应该调度哪一个进程来执行，其中 priority是一个固定不变的值，在进程创建时就已经确定，它代表了该进程的优先级，也代表这该进程在每一个调度周期中能够得到的时间片的多少； counter是一个动态变化的值，它反映了一个进程在当前的调度周期中还剩下的时间片。在每一个调度周期的开始，priority的值被赋给 counter，然后每次该进程被调度执行时，counter值都减少。当counter值为零时，该进程用完自己在本调度周期中的时间片，不再参与本调度周期的进程调度。当所有进程的时间片都用完时，一个调度周期结束，然后周而复始。另外可以看出Linux系统中的调度周期不是静态的，它是一个动态变化的量，比如处于可运行状态的进程的多少和它们priority值都可以影响一个epoch的长短。值得注意的一点是，在2.4以上的内核中， priority被nice所取代，但二者作用类似。

可见SCHED_OTHER调度策略本质上是一种比例共享的调度策略，它的这种设计方法能够保证进程调度时的公平性--一个低优先级的进程在每一个epoch中也会得到自己应得的那些CPU执行时间，另外它也提供了不同进程的优先级区分，具有高priority值的进程能够获得更多的执行时间。

对于实时进程来说，它们使用的是基于实时优先级rt_priority的优先级调度策略，但根据不同的调度策略，同一实时优先级的进程之间的调度方法有所不同：

SCHED_FIFO：不同的进程根据静态优先级进行排队，然后在同一优先级的队列中，谁先准备好运行就先调度谁，并且正在运行的进程不会被终止直到以下情况发生：1.被有更高优先级的进程所强占CPU；2.自己因为资源请求而阻塞；3.自己主动放弃CPU（调用sched_yield）；

SCHED_RR：这种调度策略跟上面的SCHED_FIFO一模一样，除了它给每个进程分配一个时间片，时间片到了正在执行的进程就放弃执行；时间片的长度可以通过sched_rr_get_interval调用得到；

由于Linux系统本身是一个面向桌面的系统，所以将它应用于实时应用中时存在如下的一些问题：

Linux系统中的调度单位为10ms，所以它不能够提供精确的定时；

当一个进程调用系统调用进入内核态运行时，它是不可被抢占的；

Linux内核实现中使用了大量的封中断操作会造成中断的丢失；

由于使用虚拟内存技术，当发生页出错时，需要从硬盘中读取交换数据，但硬盘读写由于存储位置的随机性会导致随机的读写时间，这在某些情况下会影响一些实时任务的截止期限；

虽然Linux进程调度也支持实时优先级，但缺乏有效的实时任务的调度机制和调度算法；它的网络子系统的协议处理和其它设备的中断处理都没有与它对应的进程的调度关联起来，并且它们自身也没有明确的调度机制；

3. 各种实时Linux系统

3.1. RT-Linux和RTAI

RT -Linux是新墨西哥科技大学（New Mexico Institute of Technology）的研究成果[RTLinuxWeb][Barabanov97]。它的基本思想是，为了在Linux系统中提供对于硬实时的支持，它实现了一个微内核的小的实时操作系统（我们也称之为RT-Linux的实时子系统），而将普通Linux系统作为一个该操作系统中的一个低优先级的任务来运行。另外普通Linux系统中的任务可以通过FIFO和实时任务进行通信。RT-Linux的框架如图 1所示：

图 1 RT-Linux结构

RT -Linux的关键技术是通过软件来模拟硬件的中断控制器。当Linux系统要封锁CPU的中断时时，RT-Linux中的实时子系统会截取到这个请求，把它记录下来，而实际上并不真正封锁硬件中断，这样就避免了由于封中断所造成的系统在一段时间没有响应的情况，从而提高了实时性。当有硬件中断到来时， RT-Linux截取该中断，并判断是否有实时子系统中的中断例程来处理还是传递给普通的Linux内核进行处理。另外，普通Linux系统中的最小定时精度由系统中的实时时钟的频率决定，一般Linux系统将该时钟设置为每秒来100个时钟中断，所以Linux系统中一般的定时精度为 10ms，即时钟周期是10ms，而RT-Linux通过将系统的实时时钟设置为单次触发状态，可以提供十几个微秒级的调度粒度。

RT-Linux实时子系统中的任务调度可以采用RM、EDF等优先级驱动的算法，也可以采用其他调度算法。

RT -Linux对于那些在重负荷下工作的专有系统来说，确实是一个不错的选择，但他仅仅提供了对于CPU资源的调度；并且实时系统和普通Linux系统关系不是十分密切，这样的话，开发人员不能充分利用Linux系统中已经实现的功能，如协议栈等。所以RT-Linux适合与工业控制等实时任务功能简单，并且有硬实时要求的环境中，但如果要应用与多媒体处理中还需要做大量的工作。

意大利的RTAI( Real-Time Application Interface )源于RT-Linux，它在设计思想上和RT-Linux完全相同。它当初设计目的是为了解决RT-Linux难于在不同Linux版本之间难于移植的问题，为此，RTAI在 Linux 上定义了一个实时硬件抽象层，实时任务通过这个抽象层提供的接口和Linux系统进行交互，这样在给Linux内核中增加实时支持时可以尽可能少地修改 Linux的内核源代码。

3.2. Kurt-Linux

Kurt -Linux由Kansas大学开发，它可以提供微秒级的实时精度[KurtWeb] [Srinivasan]。不同于RT-Linux单独实现一个实时内核的做法，Kurt -Linux是在通用Linux系统的基础上实现的，它也是第一个可以使用普通Linux系统调用的基于Linux的实时系统。

Kurt-Linux将系统分为三种状态：正常态、实时态和混合态，在正常态时它采用普通的Linux的调度策略，在实时态只运行实时任务，在混合态实时和非实时任务都可以执行；实时态可以用于对于实时性要求比较严格的情况。

为了提高Linux系统的实时特性，必须提高系统所支持的时钟精度。但如果仅仅简单地提高时钟频率，会引起调度负载的增加，从而严重降低系统的性能。为了解决这个矛盾， Kurt-Linux采用UTIME所使用的提高Linux系统中的时钟精度的方法[UTIMEWeb]：它将时钟芯片设置为单次触发状态（One shot mode），即每次给时钟芯片设置一个超时时间，然后到该超时事件发生时在时钟中断处理程序中再次根据需要给时钟芯片设置一个超时时间。它的基本思想是一个精确的定时意味着我们需要时钟中断在我们需要的一个比较精确的时间发生，但并非一定需要系统时钟频率达到此精度。它利用CPU的时钟计数器TSC (Time Stamp Counter)来提供精度可达CPU主频的时间精度。

对于实时任务的调度，Kurt-Linux采用基于时间（TD）的静态的实时CPU调度算法。实时任务在设计阶段就需要明确地说明它们实时事件要发生的时间。这种调度算法对于那些循环执行的任务能够取得较好的调度效果。

Kurt -Linux相对于RT-Linux的一个优点就是可以使用Linux系统自身的系统调用，它本来被设计用于提供对硬实时的支持，但由于它在实现上只是简单的将Linux调度器用一个简单的时间驱动的调度器所取代，所以它的实时进程的调度很容易受到其它非实时任务的影响，从而在有的情况下会发生实时任务的截止期限不能满足的情况，所以也被称作严格实时系统（Firm Real-time）。目前基于Kurt-Linux的应用有：ARTS（ATM Reference Traffic System）、多媒体播放软件等。另外Kurt-Linux所采用的这种方法需要频繁地对时钟芯片进行编程设置。

3.3. RED-Linux

RED -Linux是加州大学Irvine分校开发的实时Linux系统[REDWeb][ Wang99]，它将对实时调度的支持和Linux很好地实现在同一个操作系统内核中。它同时支持三种类型的调度算法，即：Time-Driven、 Priority-Dirven、Share-Driven。

为了提高系统的调度粒度，RED-Linux从RT-Linux那儿借鉴了软件模拟中断管理器的机制，并且提高了时钟中断频率。当有硬件中断到来时，RED-Linux的中断模拟程序仅仅是简单地将到来的中断放到一个队列中进行排队，并不执行真正的中断处理程序。

另外为了解决Linux进程在内核态不能被抢占的问题， RED-Linux在Linux内核的很多函数中插入了抢占点原语，使得进程在内核态时，也可以在一定程度上被抢占。通过这种方法提高了内核的实时特性。

RED-Linux的设计目标就是提供一个可以支持各种调度算法的通用的调度框架，该系统给每个任务增加了如下几项属性，并将它们作为进程调度的依据：

Priority：作业的优先级；

Start-Time：作业的开始时间；

Finish-Time：作业的结束时间；

Budget：作业在运行期间所要使用的资源的多少；

通过调整这些属性的取值及调度程序按照什么样的优先顺序来使用这些属性值，几乎可以实现所有的调度算法。这样的话，可以将三种不同的调度算法无缝、统一地结合到了一起。

10. linux cpu调度问题

有的小伙伴一直在用虚拟机，感觉拿东西用起来就像是在拿着一个假东西的模拟器，真是不爽，下面小编就给大家推荐一个史上最简单的安装linux的方法！
工具/原料

ubuntu系统
笔记本或者台式机都可以
甚至是手机nenux5也可以（手机安装，有需要的小编可以教给大家）
方法/步骤

下载Ubutu的linux系统，这里小编就不给网址了，大家自己搜索吧
注意自己的操作系统是32位还是64位，你要下载对应的版本哦

小编的是32位的，所以自己下载的32位的系统
下载完后，解压到一个空盘里，这里小编是放到了F盘（忍痛把岛国片子删掉了，嘻嘻）
找到，exe文件，打开

弹出对话框

注意选择安装路径，这里小编果断的选择了F盘（为小编辛苦攒下的N个G的岛国片默哀）

8
点击安装，ok
9
接下来会有几次重启，请小伙伴耐心等待哦