操作系统实验六实验报告

实验六：调度器

---

练习0：填写已有实验

使用meld可以简单地将前几个lab的代码填入lab6中，但是要注意在这次实验中，部分代码需要做出修改，如下，主要是trap_dispatch、alloc_proc这两个函数

• kern/trap/trap.c中lab5的部分代码

/* LAB6 YOUR CODE */
/* you should upate you lab5 code
 * IMPORTANT FUNCTIONS:
 * sched_class_proc_tick
 */
ticks++;
assert(current != NULL);
sched_class_proc_tick(current);     //注意，需要到kern/schedule/sched.c中将sched_class_proc_tick前的static去掉，否则会出现未定义错误
break;

• kern/process/proc.c中lab5的部分代码

//LAB6 YOUR CODE : (update LAB5 steps)
/*
 * below fields(add in LAB6) in proc_struct need to be initialized
 *     struct run_queue *rq;                       // running queue contains Process
 *     list_entry_t run_link;                      // the entry linked in run queue
 *     int time_slice;                             // time slice for occupying the CPU
 *     skew_heap_entry_t lab6_run_pool;            // FOR LAB6 ONLY: the entry in the run pool
 *     uint32_t lab6_stride;                       // FOR LAB6 ONLY: the current stride of the process
 *     uint32_t lab6_priority;                     // FOR LAB6 ONLY: the priority of process, set by lab6_set_priority(uint32_t)
 */
proc->rq = NULL;                //初始化运行队列为空
list_init(&(proc->run_link));   //初始化运行队列指针
proc->time_slice = 0;           //初始化时间片为0
proc->lab6_run_pool.parent = proc->lab6_run_pool.left = proc->lab6_run_pool.right = NULL;   //初始化优先队列的相关指针为空
proc->lab6_stride = 0;          //初始化步数为0
proc->lab6_priority = 0;        //初始化优先级为0（优先级越大越优先）

---

练习1：使用Round Robin调度算法

Round Robin算法的基本原理是让所有运行状态的进程分时轮流使用处理机。当前进程的时间片用完之后，调度器将当前进程放置到运行队列的尾部，再从其头部取出进程进行调度。进程控制块中增加了一个成员变量proc->time_slice，用来记录进程当前的可运行时间片段。在每个时钟中断到时的时候，操作系统会递减当前执行进程的时间片，当时间片为0时，就意味着这个进程需要把CPU让给其他进程执行，于是操作系统就需要让此进程重新回到运行队列的尾部，且重置此进程的时间片为就绪队列的成员变量最大时间片值，然后再从队列头部取出一个新的进程执行。
Round Robin调度算法的实现包含在default_sched.c中，源码及解释如下

static void
RR_init(struct run_queue *rq) {
    list_init(&(rq->run_list));                            //初始化运行队列
    rq->proc_num = 0;                                      //运行队列中进程个数初始化为0
}

static void
RR_enqueue(struct run_queue *rq, struct proc_struct *proc) {
    assert(list_empty(&(proc->run_link)));                 //确保要入队的进程并没有在运行队列中
    list_add_before(&(rq->run_list), &(proc->run_link));   //将进程加入到运行队列
    if (proc->time_slice == 0 || proc->time_slice > rq->max_time_slice) {
        proc->time_slice = rq->max_time_slice;             //重置时间片
    }
    proc->rq = rq;                                         //更新运行队列
    rq->proc_num ++;                                       //运行队列进程数加1
}

static void
RR_dequeue(struct run_queue *rq, struct proc_struct *proc) {
    assert(!list_empty(&(proc->run_link)) && proc->rq == rq);  //确保要出队的进程在当前的队列中
    list_del_init(&(proc->run_link));                      //将进程从运行队列中移除
    rq->proc_num --;                                       //运行队列进程数减1
}

static struct proc_struct *
RR_pick_next(struct run_queue *rq) {
    list_entry_t *le = list_next(&(rq->run_list));
    if (le != &(rq->run_list)) {
        return le2proc(le, run_link);                      //返回队列中待运行进程的第一个
    }
    return NULL;                                                            
}

static void
RR_proc_tick(struct run_queue *rq, struct proc_struct *proc) {
    if (proc->time_slice > 0) {
        proc->time_slice --;                               //每一个时钟中断进程的时间片减1
    }
    if (proc->time_slice == 0) {
        proc->need_resched = 1;                            //当进程时间片用完时进行进程切换
    }
}

struct sched_class default_sched_class = {                 //将RR调度算法包装成统一的接口供ucore使用
    .name = "RR_scheduler",
    .init = RR_init,
    .enqueue = RR_enqueue,
    .dequeue = RR_dequeue,
    .pick_next = RR_pick_next,
    .proc_tick = RR_proc_tick,
};

ucore系统通过定义在kern/schedule/sched.c中的schedule函数真正对进程进行调度，源码及解释如下

void
schedule(void