Linux系统进程优化理论与方法

Linux系统的任务调度机制

一、进程的切换流程

在Linux操作系统中，进程切换切换的是内存地址空间、内核态堆栈和硬件上下文。

1、硬件上下文

进程切换的时候，要把被切出的进程的一些寄存器信息存起来，等到再切回这个进程的时候，要把之前存起来的这组数据再写回寄存器里。包括存储着当前指令地址的eip寄存器，当前栈地址的esp寄存器等。进程恢复时，必须装进寄存器的一组数据。

在早期的linux系统当中，利用Inter体系结构所提供的硬件支持的优势，通过farjump指令指向next进程的TSS描述符的选择符，实现了进程的切换；当执行这条指令时，CPU通过自动保存原来的硬件上下文，装入新的硬件 上下文来执行硬件上下文的切换。但在Linux2.2之后，使用软件方法来进行进程的切换：

通过一组mov指令的有序执行逐步进行切换，这样能较好的控制被装入数据的合法性。尤其是，这使检查段寄存器的值成为可能。相较于farjump指令，当当前切换的代码在将来可能再增强时，可以有机会优化上下文切换。

2、硬件支持

硬件上下文的存储位置是哪些地方呢？答案是：TSS段和进程描述符下的thread_struct结构体内。

tss_struct：

struct tss_struct {

u32 reserved1;

u64 rsp0;

u64 rsp1;

u64 rsp2;

u64 reserved2;

u64 ist[7];

u32 reserved3;

u32 reserved4;

u16 reserved5;

u16 io_bitmap_base;

* The extra 1 is there because the CPU will access an

* additional byte beyond the end of the IO permission

* bitmap. The extra byte must be all 1 bits, and must

* be within the limit. Thus we have:

* 128 bytes, the bitmap itself, for ports 0..0x3ff

* 8 bytes, for an extra "long" of ~0UL

unsigned long io_bitmap[IO_BITMAP_LONGS + 1];

} __attribute__((packed)) ____cacheline_aligned;

TSS结构体，每个CPU只有一个。而thread_struct是每个进程有一个，用来存放其他的硬件上下文

struct thread_struct {

unsigned long rsp0;

unsigned long rsp;

unsigned long userrsp; /* Copy from PDA */

unsigned long fs;

unsigned long gs;

unsigned short es, ds, fsindex, gsindex;

/* Hardware debugging registers */

unsigned long debugreg0;

unsigned long debugreg1;

unsigned long debugreg2;

unsigned long debugreg3;

unsigned long debugreg6;

unsigned long debugreg7;

/* fault info */

unsigned long cr2, trap_no, error_code;

/* floating point info */

union i387_union i387;

/* IO permissions. the bitmap could be moved into the GDT, that would make

switch faster for a limited number of ioperm using tasks. -AK */

int ioperm;

unsigned long *io_bitmap_ptr;

/* cached TLS descriptors. */

u64 tls_array[GDT_ENTRY_TLS_ENTRIES];

};

switch_on宏：

硬件上下文用switch_on(prev, next, last)宏来实现；是schedule()中的重要一步。prev和next是入参，容易理解prev代表将要切出的进程，一般是current，next是要替换上来的进程。那么last呢？这里last是一个出参，在执行switch_to宏时，会先把prev写入eax寄存器，在执行完之后，会把eax寄存器中的内容写到last中。我们可以把last理解成切换后的prev的前继。假设现在prev指向A进程，next指向B进程，那么切完后，prev指向的就是B了，此时的last就指向B的前继，也就是A。

二、定时测量技术

在Linux系统内核中，定时测量的方式主要有两种：1、持续记录当前的时间和日期 2、维持定时器（滴答时钟）

1、定时器基础的硬件设备

实时时钟（RTC）：独立于CPU和其他芯片，依靠小电池或蓄电池供电。RTC能在IRQ8上发出周期性的中断，中断频率在2Hz~8192Hz之间；也可以通过编程以使当RTC到达某个值时，触发IRQ8线，也就是作为一个闹钟来使用。

时间标记计数器（TSC）：现在几乎所有的微处理器都包含一个CLK的输入引线，它接收一个外部振荡器的时钟信号。而在处理器的内部存在一个64位或32位的时间标记计数器（TSC）寄存器，这个寄存器是一个计数器，CLK引线每个时钟信号到来，则寄存器计数加1；Linux利用这个寄存器可以获得更加准确的定时。

可编程间隔定时器（RIT）：与TSC比较，RIT是一个固定的频率（由内核确定），这个定时器通过发送一个定时中断（timer interrupt）来通知内核又一个时间间隔过去了。一般而言，短的节拍可以获得较好的系统响应。短的时间可以使系统内核态花费较长的时间，但这就导致用户态程序时间不多，运行就慢了。

2、CPU的分时系统（time-sharing）

定时器的中断对于可运行的进程之间共享CPU的时间是必不可少的，通常系统会给每个进程分配一个时间片，如果进程执行时间片到达时，进程还未终止，那么系统将调用schedule函数选择一个新的进程投入运行。时间片总是一个节拍的倍数（多个定时中断节拍）。PID=0的进程不必与系统其他进程共享CPU时间，因为PID=0的进程只有在其他进程都不执行时，才会执行。

3、定时器的作用

定时器是一个软件工具，它允许在将来某个时刻，当给定的时间间隔用完时调用指定的函数。Linux考虑了三种类型的定时器：静态定时器(static timer)、动态定时器(dynamic timer)和间隔定时器(interval timer)；前两种定时器又内核态使用，第三种可以由进程在用户态下创建。注意：Linux系统对定时器函数的检查总是有中断底半部完成，且底半部被激活以后，通常不会立马执行；因此内核无法保定时中断函数在定时器到达时间后立即执行；对于对实时性要求较高的功能，采用定时器并不适用。

四、进程调度（重要）

1、调度策略：

Linux系统的任务调度是基于前面所学的分时技术(time-sharing)，允许多个进程“并发”运行就意味着CPU的时间被粗略的分成了“片”，给每个可运行的进程分配一片。分时技术依赖的是内核的定时中断技术，因此对进程是不可见的。在Linux系统中，进程的优先级是动态的，调度程序跟踪进程做了些什么，并周期性的调整进程的优先级；对于较长时间没有使用CPU的进程，通过动态提高他们的优先级来执行他们；对于已经在CPU上运行了较长时间的进程，则降低优先级来处罚他们。

在Linux系统这类分时系统中，我们可以把进程分为三类：交互式进程，这些进程经常与用户发生信息交互，因此要花许多时间来等待击键或鼠标操作；典型的情况是，平均延时要低于50到150ms，且要稳定。批处理进程，这些进程不必与用户交互，所以经常在后台运行；因为他们通常必须要很快的响应，因此，他们常受到调度程序的处罚；典型的批处理程序有程序设计语言的编译程序、数据库的搜索引擎及科学计算。实时进程，这些进程有很强的调度需要，这样的进程绝不会被较低优先级的进程阻塞，他们需要一个短的响应时间，且这个响应时间的变化很小；典型的实时进程有视频和音频应用程序、机器人控制程序及物理传感器上收集数据的程序。

在Linux系统中，调度算法可以明确地确认所有实时进程的身份，但没办法区分交互式程序和批处理程序；为了为交互式应用程序提供好的响应时间，所有Linux系统包括类似系统都隐含地支持IO范围的进程（IO设备操作）胜过CPU范围的进程（算法程序）。Linux内核态进程是非抢占式的，而用户态进程是抢占式的。

2、调度算法：

Linux系统调度算法把CPU的时间片划为时期(epoch)。在一个单独的时期内，每一个进程有一个独立的时间片，时间持续的时间从这个时期开始计算。一般情况下，不同的进程有不同大小的时间片；时间片的值是在一个时期内，分配给进程的最大CPU时间部分。在同一个时期中，一个进程可以几次被调度程序选中（只要它的时间片还未用完）；当所有进程的时间片都被使用完了，一个CPU时期才算结束。在这种情况下，调度程序算法重新计算所有进程的时间片并调整优先级，然后，一个新的时期开始。

基本时间片：每个进程都有一个基本时间片，如果进程在前一个时期已经用完他的时间片，那么这个时间片就是调度程序赋给进程的基本时间片。用户可以通过调用nice()或setpriority()系统调用来改变进程的基本时间片（详见第3点）。新进程总是继承父进程的基本时间片。

Linux系统的调度程序有三种优先级：静态优先级，他不随调度程序改变，可以通过用户调用sched_setscheduler()去修改，修改范围是0~99，数值越小，则优先级越高。动态优先级(基本优先级)，这种优先级只应用于普通进程；实质上，他是基本时间片（也可以叫基本优先级）与当前时期内的剩余时间片之和,可以通过nice()或者shell指令来配置，范围是-20~19。实时优先级，这个是基于实时进程的概念，实时优先级的与进程的动态优先级成线性关系，这种关系是固定的。注意：实时进程的静态优先级总是高于普通进程的动态优先级，只有当TASK_RUNNING状态没有实时进程时，调度程序才开始运行普通进程。在Linux系统中，任务优先级相同的进程或线程可以有多个。

Linux系统任务调度的三种模式：SCHED_FIFO先入先出实时进程，当调度程序把CPU分配给一个进程时，该进程的描述符还留在运行队列链表的当前位置，如果没有其他更高优先级的实时进程是可运行的，这个进程可以随心所欲的使用CPU，即使具有相同优先级的实时进程是可运行的。SCHED_RR循环轮转的实时进程，当调度程序把CPU分配给一个进程时，这个进程的描述符被放在运行队列的末尾，这种策略确保了把CPU时间公平的分配给其他实时进程，但这种轮询也是基于静态优先级循序的，优先级较高，被轮询的次数就比较多。SCHED_OTHER默认的普通分时进程，这种模式是Linux系统中所有进程的默认调度模式，非实时任务调度。

3、与调度相关的系统调用：

这里提供几个不错的博客：

http://blog.chinaunix.net/uid-20384806-id-1954380.html

https://www.cnblogs.com/qinwanlin/p/8631185.html

主要应用层函数解析：

int nice(int inc); //include <unistd.h>，允许进程改变他们的基本优先级，对应的shell指令是：nice -n inc xxx,inc设置值范围：-20~20;这个函数只有超级用户root才可以生效，且即使修改了优先级，在系统运行过程中，这个优先级还是会变化//

int sched_setscheduler(pid_t pid, int policy,const struct sched_param *param); //include <sched.h>，这个函数可以设置指定线程或进程的调度策略和静态优先级。结构体：sched_param.sched_priority 可以指定优先级等级，这个函数的配置只对实时进程有效//

int sched_get_priority_max(int policy); //include <sched.h> ，该函数返回的是由调度策略policy标识的调度算法的最大优先级，对于实时调度策略SCHED_FIFO和SCHE_RR的优先级范围是1~99，这里，数值越大，优先级越高

///

四、基于具体项目问题的研究

1、解决伺服电机周期控制的周期性问题：实现的一个进程，每个周期时间要给伺服系统发送一个位置指令，比如1ms发送一个；如果太早或太晚发送，伺服系统就会出现速度波动。

实例创建线程的代码片段：

pthread_t p_id;

pid_t pid = getpid(); //获取当前主进程的ID号//

struct sched_param param;

pthread_attr_t attr;

param.sched_priority = sched_get_priority_max(SCHED_RR); //获取RR调度模式下的最高优先级//

sched_setscheduler(pid, SCHED_RR, &param); //配置进程为实时进程，且配置为最高静态优先级//

/*配置线程的系统调度机制和优先级*/

pthread_attr_init(&attr);

pthread_attr_setschedpolicy(&attr,SCHED_RR);

pthread_attr_setscope(&attr,PTHREAD_SCOPE_SYSTEM); //允许线程与系统内的所有线程抢占资源//

pthread_attr_setschedparam(&attr,&param); //配置实时线程的静态优先级//

pthread_attr_setinheritsched(&attr,PTHREAD_EXPLICIT_SCHED); //调用这个函数保证对线程的配置可以生效//

pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);

pthread_create(&p_id,&attr,Axis_Mode_func,NULL);

pthread_create(&p_id,&attr,Axis_Mode_func,NULL); //Create two pthread to running Axis //

项目需求的分析：在这个项目中，主进程用来实现项目的主要功能，他是一个功能框架；这意味着，系统允许主进程占用绝大多数CPU任务调度的资源，所以，可以考虑将主进程配置为实时进程提高进程优先级到最高优先级；为了进一步提高进程优先级，运行此进程的SHELL指令为：nice -n -20 ./xxx；这意味着，进程的基本优先级也是最高的。考虑到主进程还会在实际运行中，创建线程以运行更多对实时性有严格要求的功能，为了保证这些实时线程之间可以公平地占用CPU，所以调度策略采用了时间片轮询的方式，即SCHED_RR；项目中其实是基于一个最高优先级进程创建一个个个实时线程，所以线程每次任务周期休眠时间也会影响系统对任务的轮询切换。

五、单个进程程序的几个优化建议

1、变量申明的时机与位置

对于任何一个进程与线程来说，申明的变量常用的就是：局部变量、全局变量、静态变量、以及动态变量。对于一个嵌入式设备来讲，CPU资源被认为比较紧张，我们通常希望CPU尽可能将所有资源集中在程序的运算与逻辑处理上。

局部变量：如果变量是某个函数调用时才被需要，且该函数不需要经常调用的话，申明局部变量可以节省进程的栈内存资源，但CPU运行该函数时，需要花费时间去进程栈中开辟空间，对CPU造成一定的消耗。

全局变量：如果变量是进程内共享的；或者在某个函数中被调用，但该函数需要经常被执行，我们一般将变量申明为进程的全局变量；因为全局变量在进程运行时被分配，进程结束时被其他进程替代，相对于局部变量来说，不需要消耗太多CPU。但是，需要注意的是，对于Linux系统，每个进程的栈内存默认限制为2MB（window为8MB）。

动态创建变量（malloc）：动态创建变量是被分配到系统的堆内存中的，理论上可以认为大小不受限制。对于一个进程而言，如果变量很多，且进程内的函数或变量需要被经常访问，那么建议动态创建。注意，动态创建的变量如果不用，需要手动释放内存；我们应尽可能的让动态创建的变量生命周期等同于整个系统的运行周期，这样做的好处是CPU运行进程时，无需再频繁申请内存。有一个缺点，就是CPU访问动态内存的速度比较慢。

静态变量：这种变量在程序编译时会被初始化并编译到可执行文件的静态变量区，属于文本类型变量。个人通常不用，因为文本访问的速度是比较慢的，且cpu调用该进程时，需要先将这些变量拷贝到内存，再执行，然后在进程结束时，写回文本，这些操作也会消耗CPU资源。

内存分配时，尽可能使用连续分配法，且大小是4的倍数。这样可以提高CPU高速缓存区的命中率！！善用结构体来封装变量。

2、判断语句的可重入性

在开发实际项目中，大家会发现，使用最多的语句就是各种条件判断语句。对CPU而言，这些语句实际上就是各种寄存器的指针和跳转，对CPU也会有一定的算法消耗。

可用switch的，尽量用switch语句：相较于if....else...语句，使用switch语句实际上会在内存上建立一个条件转换表，他会占用一定的内存，但因为内存中事先创建好了该表格，所以执行起来不需要反复判断跳转指针，运行速度会很快（牺牲空间获得时间）。但是，switch语句本身也存在一定的局限性，比如他只能判断单一条件，或者你可以switch嵌套；通常情况下，我会将switch语句与if语句结合起来使用。

if....else....语句：使用这种条件判断语句十分常见，但对于嵌入式设备而言，cpu反复判断不太可能成立的条件会造成资源的浪费，这是因为现在的CPU引入了片内高速缓存区的技术，cpu会将经常执行和使用的代码与变量拷贝到该区域内，实现纳秒级别的运算。但如果进程中的条件判断语句是不经常成立的，就会导致cpu无法正常使用这个机制，进程执行将在普通内存下进行，其实时性将大打折扣。通常会在实际开发中，充分考虑条件的成立频率，将高频成立的条件放在低频的之前。

goto xxx语句：很对人不愿意使用它，因为认为他容易打乱程序的逻辑结构。个人认为适当的使用他可以节省代码量，提高代码的复用性；这在一定程度上可以减轻CPU做任务切换时的负担，且有可能减少程序执行的步骤。

3、不同延时函数的特性

这里的延时函数特指可以使线程或进程休眠的函数，在实时系统中，适当的让进程休眠，可以给其他对实时性要求较高的进程有足够的CPU使用权。这里列出我所知的几个应用编程的延时休眠方法：

unsigned int sleep(unsigned int seconds)函数：以秒为单位的延时，其精度不高。该函数是可以被中断的，也就是说，进程在sleep过程中可能会被其他进程打断，且再次回来时，将直接执行sleep的下一条语句。函数返回值是sleep被中断或结束时，剩余的秒数。实际上，定时时间到后，会产生一个闹钟信号给CPU，属于信号中断。

int usleep(useconds_t usec)函数：以微秒为单位的延时休眠，一样是属于精度不高的延时；且可以被信号中断。函数返回值是剩余延时微秒数。被中断后，将从该函数的下一条语句开始执行。

int nanosleep(const struct timespec *req, struct timespec *rem)函数：以纳秒级别为单位的延时，其精度很大程度取决于CPU晶振的频率。 nanosleep()是Linux中的系统调用，它是使用定时器来实现的，该调用使调用进程睡眠，并往定时器队列上加入一个timer_list型定时器，time_list结构里包括唤醒时间以及唤醒后执行的函数，通过nanosleep()加入的定时器的执行函数仅仅完成唤醒当前进程的功能。系统通过一定的机制定时检查这些队列（比如通过系统调用陷入核心后，从核心返回用户态前，要检查当前进程的时间片是否已经耗尽，如果是则调用schedule()函数重新调度，该函数中就会检查定时器队列，另外慢中断返回前也会做此检查），如果定时时间已超过，则执行定时器指定的函数唤醒调用进程。当然，由于系统时间片可能丢失，所以nanosleep()精度也不是很高。

int select(int nfds, fd_set *readfds, fd_set *writefds,

fd_set *exceptfds, struct timeval *timeout)函数：利用这个等待文件操作函数可以实现延时功能，这个延时的精度比较高，通常应用在对实时性要求较高的场合。该延时时间到后，会向系统发送一个超时信号，该信号输入软件中断级别；所以通常系统会很快响应并执行函数下的进程语句。

4、减少IO设备文件的操作，减少用户态与内核态的切换

对于Linux系统和CPU来讲，最消耗CPU资源的就是IO设备操作和数据运算。在Linux系统的潜规则中，IO设备操作的优先级会比运算高，通常会更多的获得执行时间片。

尽量减少不必要的IO设备读写操作：Linux系统中的IO设备操作包括/dev/xxx字符设备、/sys/class硬件总线设备以及磁盘文件的读写。这里的操作不仅包括写，也包括读。频繁的IO设备操作会让CPU反复在用户态与内核态之间切换，这种切换会消耗cpu的资源；个人建议如果一定要进行IO设备操作的话，可以在每次完成操作后，让进程休眠，这种方法可以给系统的其他进程执行的机会。

必要时，使用数据运算代替IO操作：这个跟实际的业务需求有关系，有时候，为了避免频繁的IO设备操作，可以使用变量运算来代替部分IO读写动作。当然，这是有一定代价的优化，被优化的进程运行性能可能会降低。