服务器架构设计4------进程调度

今天让我们来一起了解一下linux cpu的进程调度，对于linux服务器，通常会碰到2个问题

1、实时性，有什么办法能确保某一个进程能优先运行、并且不受时间片的限制，只有等待它运行完了，其它进程才能运行？

2、多核cpu，有什么办法能够自定义，绑定某些进程在某些cpu上？

那么在探讨这俩问题之前，先来了解一下linux进程调度基础知识。

多任务系统分为2类。

非抢占式多任务：除非进程自己主动停止运行，否则它会一直执行；

抢占式多任务：有调度程序来决定什么时候停止某一进程的运行，以便其它进程能够得到执行机会。linux采用的是此种方式。

进程对于处理的使用上，也分为2类：

I/O消耗型：有大量的磁盘、网络io操作，这种进程，其大部分时间都堵塞在io请求及其响应上；

处理器消耗型：这种程序大部分是算法很复杂，一个极端的例子就是while(1)，死循环。

进程优先级：

高优先级的进程，先运行，并且其享用的时间片较长。低优先级进程则反之。

时间片：

过大、等待时间长，过小、进程切换频繁。默认时间片20ms。

调度的公平性

在支持多进程的系统中，理想情况下，各个进程应该是根据其优先级公平地占有CPU。而不会出现“谁运气好谁占得多”这样的不可控的情况。

linux实现公平调度基本上是两种思路：
1、给处于可执行状态的进程分配时间片（按照优先级），用完时间片的进程被放到“过期队列”中。等可执行状态的进程都过期了，再重新分配时间片；
2、动态调整进程的优先级。随着进程在CPU上运行，其优先级被不断调低，以便其他优先级较低的进程得到运行机会；
后一种方式有更小的调度粒度，并且将“公平性”与“动态调整优先级”两件事情合二为一，大大简化了内核调度程序的代码。因此，这种方式也成为内核调度程序的新宠。
强调一下，以上两点都是仅针对普通进程的。而对于实时进程，内核既不能自作多情地去动态调整优先级，也没有什么公平性可言。

一个有趣的例子：

一个系统，2个进程，一个文字编辑、一个视频编码。前者是I/O消耗型，后者处理器消耗型。那么处理器在对待这两种进程是如何分配优先级和时间片的呢。

首先，文字编辑，其大部分时间都在I/O等待上，需要对用户的请求及时响应，所以其优先级高，并且时间片长。当有用户请求时，会中断视频编码的运行。当需要等待I/O响应时，会及时交出时间片，给视频编码用。

相反，视频编码，优先级低，时间片短。

===========================================================================

好，基本知识介绍完了，下面来回答开篇提的2个问题。

linux两种实时调度策略：

SCHED_NORMAL：普通调度策略，平时我们所使用，基于时间片的抢占式调度策略。

SCHED_FIFO：先入先出调度，不使用时间片，一旦一个SCHED_FIFO级进程处于可执行状态，就会一直执行下去，直到它自己受阻塞或显式地释放cpu为止。FIFO比NORMAL优先级高，只有较高优先级的SCHED_FIFO或SCHED_RR任务才能抢占SCHED_FIFO任务。

SCHED_RR：和SCHED_FIFO类似，但是使用时间片，其优先级比SCHED_NORMAL高。当SCHED_RR时间片耗尽，相同优先级的其它实时进程会被轮流调度，注意是相同优先级的实时进程。换句话说，当其时间片耗尽，只有相同优先级的SCHED_FIFO和SCHED_RR可以被cpu调度，而低优先级的SCHED_NORMAL是不会被轮流到的。当然高优先级的实时进程，可以抢占。

实时优先级范围0~99，99是最高优先级。可以通过函数sched_get_priority_max获取。

总结：实时调度，可以使用SCHED_FIFO和SCHED_RR，区别是前者没有时间片，知道其运行完毕或受阻塞，后者有时间片，时间片耗尽，cpu可以交给同优先级的实时任务使用。

说了一大堆，到底如何设置实时调度策略，函数有哪些呢？

nice() //设置进程的nice值
sched_setscheduler()//设置进程的调度策略
sched_getscheduler()//获取进程的调度策略
sched_setparam()//设置进程的实时优先级
sched_getparam()//获取进程的实时优先级
sched_get_priority_max()//获取实时优先级最大值
sched_get_priority_min()//获取实时优先级最小值
sched_rr_get_interval()//获取进程时间片
sched_setaffinity()//设置进程处理器的亲和力
sched_getaffinity()//获取进程处理器的亲和力
sched_yield()//暂时让出处理器

设置实时调度策略SCHED_FIFO例子：

int
rtsched_set_my_realtime_priority (int32_t prio) {
    struct sched_param schp;
    if (sched_getparam(0, &schp) < 0) {
        return(-1);
    }

    schp.sched_priority = prio;
    if (sched_setscheduler(0, SCHED_FIFO, &schp) < 0) {
        return(-1);
    }

    return(1);
}

绑定指定cpu的例子：

int
rtsched_setaffinity_by_name(int32_t cpuid)
{
    cpu_set_t mask;
    CPU_ZERO(&mask);
    CPU_SET(cpuid, &mask);
    sched_setaffinity(0, sizeof(cpu_set_t), &mask);

    return 1;
}

这是一个绑定cpu的例子，系统默认进程可以在任何一个cpu上运行，但为了保证某些进程的实时性，把它绑定在某个空闲cpu上运行也是很有必要的。

放弃cpu

好了，绑定cpu，设定优先级，都保证了某个进程的实时性，那么如果我们想暂时放弃其实时性，让其让出cpu，让别的进程运行一会，有什么办法呢？

可以调用函数sched_yield()，其将进程从活动队列移到过期队列中，交出其占用的cpu，需要注意的是，对于实时进程，不是将其放倒过期队列中，而是放到优先级队列的最后面。而不会放到过期队列中去。

需要注意的地方：

1、最好优先级，千万别随便设置，一旦设置其他进程就没得玩了，最高99，设个98就已经很高了，作者曾经试验过，一旦设置99，连ssh都连不上了，囧。。。。。。。；

2、对于cpu的绑定和优先级的设定，是可以针对线程的，O(∩_∩)O~；

3、高优先级，则代表不去释放cpu，假设有这样一种情况，pthread1、pthread2都绑定在cpu1上，并且都是实时同优先级的线程。1获取到spin_lock，然后io阻塞交出cpu给2，恰巧2和1共享同一资源，也要去spin_lock同一资源，好吧，想想看，会是什么结局，2会一直spin_lock，占用cpu，而1又获取不到cpu，这2位就在这僵着，谁也无法继续执行。囧。。。。。。。。。