标签：style blog http 使用 os io 文件 for 数据
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而言，进程调度算法简单，实效便 于理解！
标签：style blog http 使用 os io 文件 for 数据
原文地址：http://www.cnblogs.com/sfwtoms/p/3929414.html
