MINIX3 进程调度分析

MINIX3 进程调度分析 

5.1MINIX3 进程调度概要 

MINIX3 的进程调度还是非常简单的，调度算法是非常短小的，其目的就是体现 了一个简单和高效的设计原则，当然简单和高效其实很难并存，整体而言，就是 一个多队列调度算法，根据优先级来放到相应的位置。 

我们现在来看下整个图示：（下面这个图其实就是 MINIX3 初始化时用户还没有 创建进程时所显示的图），在层次一，被认为是系统层，级别最高，是包括 system 和 clock 任务，之后第 2 层就是 tty（终端进程，在 I/O 中用到的一个进程，本分 析文档暂且忽略不考虑）等等，以此往上跑，等到第 16 层，也是整个调度优先 级最低的一个进程，被称为 IDLE_Q，这个进程其实就是 nop 操作，就是空操作， 不做任何事情。当进程内部所有的进程都不能运行时，才会运行这个进程，一般 这种可能性非常小，除非系统出现了故障。 

现在我们往深入分析，上面分析了整个调度的一个架构图，现在我们想想看，什
么时候会启动这个调度程序 ？首先  MINIX3  是一个基于分时的操作系统 ，
time-sharing’os,也就是每次当发生时钟中断时，判断用户进程是否耗尽了它的时 

75 

间片，如果耗尽了它的时间片，我们将启动调度算法，来完成调度。可以看出， 这个调度程序其实就是依附在时钟任务的一个小程序，调度算法不会单独单独成 为一个进程而存在。这点非常的重要。 

其次，我们想想，如果当前的进程处于阻塞或者挂起状态，我们该怎么处理呢？ 我们也会进入内核来完成相关的调度工作。 

5.2 MINIX3 进程调度源码分析 

基本上就是以上 2 种情况。我们现在往源码内部分析，！ 

在分析之前我们应该先看下调度涉及到得一个数据结构，数据结构示意图就是上 面那副，现在看看数据结构的具体内容： 

EXTERN struct proc  *rdy_head[NR_SCHED_QUEUES];  /* ptrs to ready list headers  */ 

EXTERN struct proc  *rdy_tail[NR_SCHED_QUEUES];  /* ptrs to ready list tails  */、 

这是2个指针数组，也就是图的两边，rdy_head[]数组是调度队列的对头， 

rdy_tail[]是调度队列的队尾。这里的队列不是普通意义上的队列，是队列的一 个变形，队头和队尾都是指向进程的，这样的处理就是为了插入的高效率。 这里就不分析其中的效率。 

继续往下面看，现在看看是哪些域把这些进程连接起来的， 

struct proc  *p_nextready;  /* pointer to next ready process  */ 

这个域就是指向下一个进程。 

继续分析与调度算法相关的进程表项域

char p_priority;

//当前进程优先级

char p_max_priority;
//调度队列最大优先级
char p_ticks_left;
//进程还有多少时钟剩下
char p_quantum_size;
//本进程有多少个时钟

clock_t p_user_time;

//用户时间

clock_t p_sys_time;

//系统时间

/* current scheduling priority  */

/* maximum scheduling priority  */

/* number of scheduling ticks left  */

/* quantum size in ticks  */

/* user time in ticks  */

/* sys time in ticks  */ 

现在我们分析源码，由于涉及到调度的源码很少，主要是在 proc.c 和 restart.c 中 涉及到。先分析 proc.c 

看下  2  个函数与进程外界调度的接口函数  ：enqueue()和  dequeue()函数以及 lock_enqueue()和 lock_enqueue()调度函数。 

可以看出 sched()和 pick_proc()函数是一个功能函数，就是提供给 enqueue()和 

76 

dequeue()函数使用。 

/*=================================================================== ========* 

* enqueue *

*====================================================================

=======*/

PRIVATE void enqueue(rp)

register struct proc  *rp; /* this process is now runnable  */

{

/* Add 'rp' to one of the queues of runnable processes.    This function
is responsible for inserting a process into one of the scheduling queues.
* The mechanism is implemented here.      The actual scheduling policy is 

* defined in sched() and pick_proc(). 

将‘rp’加到其中一个运行进程队列中。这个函数主要负责将一个进程插入到 

77 

调度队列中。这种机制就在这里实现。事实上真正意义上的调度策略是被定义在 sched()和pick_proc()函数 

*/ 

int q; /* scheduling queue to use  */

int front; /* add to front or back  */

#if DEBUG_SCHED_CHECK 

check_runqueues("enqueue"); 

if  (rp->p_ready) kprintf("enqueue() already ready process\n"); #endif 

/* Determine where to insert to process.  */ 

这个函数在下面会有介绍，主要是用于决定插入哪个进程 

sched(rp, &q, &front); 

/* Now add the process to the queue.  */ 

//现在就将进程加入到队列中 这里的q代表的就是哪个队列号，由前面的sched() 函数加入。 

if  (rdy_head[q]  == NIL_PROC)  { /* add to empty queue  */

//由前面的函数可以知道，q就是想要的运行队列，如果这个队列上暂且没有进

//程，则必须要创造一个一个新的队列，并且将本进程发到进程里准备投入使用。

rdy_head[q]  = rdy_tail[q]  = rp; /* create a new queue  */

rp->p_nextready  = NIL_PROC; /* mark new end  */

}

//如果是队列已经有进程，我们需要仔细往下处理

//如果进程的时间有剩余，则将本进程加入队列表的表头

else if  (front)  { /* add to head of queue  */

rp->p_nextready  = rdy_head[q]; /* chain head of queue  */

rdy_head[q]  = rp; /* set new queue head  */

}

//如果时间用完了，就应应该加入到队列表的末尾。

else  { /* add to tail of queue  */

rdy_tail[q]->p_nextready  = rp; /* chain tail of queue  */

rdy_tail[q]  = rp; /* set new queue tail  */

rp->p_nextready  = NIL_PROC; /* mark new end  */

} 

/* Now select the next process to run.  */ 现在选择下一个进程进程运行 

pick_proc(); 

#if DEBUG_SCHED_CHECK
rp->p_ready  =  1; 

78 

check_runqueues("enqueue");
#endif 

} 

/*=================================================================== ========* 

* sched 这个函数和下个函数是MINIX调度器的主要

*内容，通过这个函数计算出谁应该被调度，之后将相应的值给设定好之后，在 内核中 

另外一个函数restart就从硬件上进行真正意义上的调动 

*==================================================================== =======*/ 

PRIVATE void sched(rp, queue, front)

register struct proc  *rp;

//计划被调度的进程

int  *queue;

//返回值1：被使用的队列号 int  *front;

//前者或者是后者

{

/* process to be scheduled  */

/* return: queue to use  */

/* return: front or back  */ 

/* This function determines the scheduling policy.    It is called whenever
a process must be added to one of the scheduling queues to decide where
to insert it.    As a side-effect the process' priority may be updated.
这个函数决定调度策略。这个函数被调用出来决定一个进程必须加到调度队列中
并且决定将这个进程插入哪里。一个负面效应就是这个进程的优先级必须被改
变。 

*/ 

static struct proc  *prev_ptr  = NIL_PROC;/* previous without time  */
int time_left  =  (rp->p_ticks_left  >  0);  /* quantum fully consumed */
//这个变量决定是否被消耗完 

int penalty  =  0; /* change in priority  */

//这个变量是用于改变进程的优先级 

/* Check whether the process has time left. Otherwise give a new quantum
* and possibly raise the priority.    Processes using multiple quantums
* in a row get a lower priority to catch infinite loops in high priority 

* processes  (system servers and drivers). 

检查这个进程是否有时间剩余，如果没有时间剩余，就给出一个新的量值并且可 能会提示这个进程的优先级。正在使用多值的量值（在数组中）的进程得到一个 较低的优先级来捕获这个高优先级进程的无限循环。 

*/ 

//如果time_left==0,也就是时间消耗完了，就进入if内部。 

if  (  ! time_left)  { /* quantum consumed  ?  */

//重新给这个进程分配一个量值 

79 

rp->p_ticks_left  = rp->p_quantum_size;  /* give new quantum  */ 

//这里是如果前一个进程也是rp,则准备捕获这个无限循环，但是必须把本进程 //的优先级降低一位，也就是把处罚值加1 

if  (prev_ptr  == rp) penalty  ++; /* catch infinite loops  */

else penalty  --; /* give slow way back  */

//这里将prev_ptr执行rp,主要是为了下面的调度做好准备 

prev_ptr  = rp; /* store ptr for next  */

} 

/* Determine the new priority of this process. The bounds are determined
* by IDLE's queue and the maximum priority of this process. Kernel task
* and the idle process are never changed in priority.
决定这个进程的新优先级。界限是由IDLE和这个进程最大的优先级所决定。内核 任务和IDLE进程是从来不会来改变优先级的 

*/ 

//如果惩罚值不是0并且rp不是内核进程，则可以改变其优先级。 

//改变的方法很简单：就是将本进程的优先级加上处罚值。并且检查是否超出优 先级的上界和优先级的下界。 

if  (penalty  !=  0 &&  ! iskernelp(rp))  { 

rp->p_priority  += penalty; /* update with penalty  */

if (rp->p_priority < rp->p_max_priority)

rp->p_priority=rp->p_max_priority;

else if  (rp->p_priority  > IDLE_Q-1)

rp->p_priority  = IDLE_Q-1;

}

/* check upper bound */

/* check lower bound  */ 

/* If there is time left, the process is added to the front of its queue, * so that it can immediately run. The queue to use simply is always the    process' current priority. 

如果这里有时间剩余，进程被加到它的队列的前端。所以它能够马上投入运 行。这个队列总是使用简单的进程当前优先级 

*/ 

*queue  = rp->p_priority;
*front  = time_left;
} 

/*=================================================================== ========* 

* pick_proc 这个函数从字面上就能够看出：这是一个选择进

程的函数。 *

*==================================================================== =======*/ 

PRIVATE void pick_proc() 

80 

{ 

/* Decide who to run now.    A new process is selected by setting 'next_ptr'. * When a billable process is selected, record it in 'bill_ptr', so that the clock task can tell who to bill for system time.
决定现在谁来运行。一个新的进程被选择处理 通过将其设定为next_ptr指向的 地方。当一个付账进程被选择，将它记录在bill_ptr里。所以系统任务能够告诉 是谁为这个系统时间付账 

*/ 

register struct proc  *rp; /* process to run  */

int q; /* iterate over queues  */

/* Check each of the scheduling queues for ready processes. The number of queues is defined in proc.h, and priorities are set in the task table.
* The lowest queue contains IDLE, which is always ready.
为每个正在准备的进程检查每一个调度队列。队列的数量被定义在proc.h文件
中，并且优先级被设定在任务进程表中。最低进队列包括IDLE进程，这个进程总 是在就绪队列中。 

*/ 

//这个函数主要是找从低优先级往高优先级扫描，只有有一个队列的队列头不是 //NIL_PROC，就将next_ptr设置成相应指向的进程-----rp。Next_ptr在后面会 //restart函数会有用。 

for  (q=0; q  < NR_SCHED_QUEUES; q++)  { 

if  (  (rp  = rdy_head[q])  != NIL_PROC)  { 

next_ptr  = rp; /* run process 'rp' next  */

if  (priv(rp)->s_flags & BILLABLE)

bill_ptr  = rp;

return;

}

}

}

/* bill for system time  */ 

/*=================================================================== ========* 

* dequeue 将正在运行的进程从调度队列中移除

* 

*==================================================================== =======*/ 

PRIVATE void dequeue(rp) 

register struct proc  *rp; /* this process is no longer runnable  */

{

/* A process must be removed from the scheduling queues, for example, because it has blocked.    If the currently active process is removed, a new process is picked to run by calling pick_proc(). 

81 

一个进程必须从调度队列中去除掉。举一个例子，因为他已经阻塞了。如果当前
活动进程被移除，一个新的进程需要被选择来运行，通过调用pick_proc()函数
*/ 

register int q  = rp->p_priority; /* queue to use  */

register struct proc  **xpp; /* iterate over queue  */

register struct proc  *prev_xp; 

/* Side-effect for kernel: check if the task's s tack still is ok? */ //检查这个进程是不是内核进程，如果是内核进程，就应该做相应的处理
if  (iskernelp(rp))  { 

if  (*priv(rp)->s_stack_guard  != STACK_GUARD) 

panic("stack overrun by task", proc_nr(rp));
} 

#if DEBUG_SCHED_CHECK 

check_runqueues("dequeue"); 

if  (! rp->p_ready) kprintf("dequeue() already unready process\n"); #endif 

/* Now make sure that the process is not in its ready queue. Remove the
* process if it is found. A process can be made unready even if it is
not    running by being sent a signal that kills it. 

现在我们确保这个进程不在他的准备队列中，如果发现这个进程就移除这个进 程。如果一个进程不在运行队列中，并且发送了一个信号杀死这个进程 则这个 进程能够移除不在等待状态。 

*/ 

//上面的注释看起来比较费劲，我们现在来往下面好好看下代码。
// 

prev_xp  = NIL_PROC; 

//扫描这个q队列，找到要找到的进程，将他从就绪队列中移除。 

for (xpp = &rdy_head[q]; *xpp != NIL_PROC; xpp = &(*xpp)->p_nextready)

{

//找到要移除的进程，我们就进入if内部 

if  (*xpp  == rp)  { /* found process to remove  */

//找到了，就替换将这个进程替换掉，这个语句是结合本循环最后一条语句实现

//的,注意看最本质的内容，这里的移除仅仅就是将调度队列绕过本进程。而需

要移除的进程不会做任何的处理。

*xpp  =  (*xpp)->p_nextready; /* replace with next chain */

//如果rp是对尾队列，则将队尾队列队尾指向遍历搜索链表的已经储存的前一个

表项。

if  (rp  == rdy_tail[q]) /* queue tail removed  */

rdy_tail[q]  = prev_xp; /* set new tail  */

if  (rp  == proc_ptr  || rp  == next_ptr) /* active process

82 

removed  */ 

//如果rp是当前活动的进程，应该调用pick_proc()函数，重新选择一个进程投 //入使用 

pick_proc(); /* pick new process to run  */

break;

}

prev_xp  =  *xpp;  /* save previous in chain  */ 

//储存遍历搜索的链表的前一个表项，和前面的语句结合使用来将本进程移除队
列 

} 

#if DEBUG_SCHED_CHECK
rp->p_ready  =  0; 

check_runqueues("dequeue");
#endif 

} 

/*=================================================================== ========* 

* lock_enqueue *

*====================================================================

=======*/

PUBLIC void lock_enqueue(rp)

struct proc  *rp; /* this process is now runnable  */

{

/* Safe gateway to enqueue() for tasks.  */

lock(3, "enqueue");

enqueue(rp);

unlock(3);

}

/*=================================================================== ========* 

* lock_dequeue *

*====================================================================

=======*/

PUBLIC void lock_dequeue(rp)

struct proc  *rp; /* this process is no longer runnable  */

{

/* Safe gateway to dequeue() for tasks.  */
lock(4, "dequeue"); 

dequeue(rp); 

83 

unlock(4); 

} 

5.3 MINIX3进程调度与中断返回处理的结合 

我们现在来回顾前面中断系统讲到的restart函数和结合内核调度实例来进一步 分析整个调度机制 

先看restart函数，同样，先把restart函数源码附上： 

!*=========================================================== ================* 

!* restart    我们从 hwint_inhandler(irq)进入到这个函数，我们现在

来着重分析这个函数 !在分析之前，我们同样要搞清楚栈和相关寄存器的内

容，首先栈还是内核栈 

之后 CS 和 IP 同样是指向这个函数的首地址，现在我们进入函数内部分析 

* 

!*=========================================================== ================* 

_restart: 

! Restart the current process or the next process if it is set. 

！！这里非常的重要，因为这里主要是用于进程的调度。 

cmp (_next_ptr), 0 ! see if another process is scheduled，这里的_next_ptr

表示在运行 restart 之后指向的进程地址。其实也就是 

jz 0f

mov     eax, (_next_ptr)  ！如果不是为 NULL，则执行流就从这里开始 

！将_next_ptr 的值存入 eax,之后将 eax 的值设置存入_proc_ptr 内存地址中,pro_ptr 是指向当前进程指针，这些指针都是已经设定好的，这个指针就就是用于下次返 回所运行的指针 

mov (_proc_ptr), eax ! schedule new process

mov (_next_ptr), 0! 这里为啥把_next_ptr 设置成为 NULL，主要原因是标

志下次在执行 

！这个 restart 例程时是否有重新设置上面那 2 个指针。如果没有就直接进入 0 标志，这个就是从最高代码效率来考虑 

这里就是通过设置前面的next_ptr指针，前面pick_proc()函数设置了next_ptr，
就是供这里使用。这个的_next_ptr和NULL比较是有原因的，你们可以想象一下，
如果发生非时钟中断时可能还是本进程作为下一次调度的对象，不是时钟中断
时，我们是可能不会来调用调度算法，那么直接就将本进程继续投入使用。并且
我们这里_next_ptr是上面调度算法函数和本restart的一个枢纽。上面的调度算
法函数就是选出了_next_ptr这个函数，现在_restart函数就将这个_next_ptr
函数投入使用。 

84 

5.4MINIX3时间调度与内核其他模块的关系 

哪里会出现调度进程调度函数呢？时钟中断有可能就会调用这个调度队列。之后 相关的消息机制也是会调用这个调度队列： 

用2个图形给予说明： 

第一个就是时钟机制可能导致触发这个调度算法函数： 

第2种可能就是消息机制触发这个调度过程： 

85 

MINIX3的调度分析基本上分析完，对于MINIX3而言，进程调度算法简单，实效便 于理解！