进程调度算法的分析与研究
合肥经济技术职业学院毕业设计论文
（2011 — 2012学年）
论文（设计）题目进程调度算法的分析及研究
院系名称电子信息系
专业班级计算机应用
学生姓名mm
学号mm
指导教师mm
日期2012年4月16日
目录
摘要 (3)
关键词 (3)
引言 (4)
第一章进程概述 (5)
1.1进程调度 (5)
1.1.1进程的属性 (5)
1.1.2进程的基本状态 (5)
1.2进程调度的三种算法 (6)
第二章算法分析 (7)
2.1先来先服务调度算法 (7)
2.1.1算法思想 (7)
2.1.2 算法流程图 (8)
2.1.3 程序代码 (8)
2.1.4测试结果 (12)
2.2优先数调度算法 (12)
2.2.1算法思想 (12)
2.2.2算法流程图 (13)
2.2.3程序代码 (14)
2.2.4测试结果 (16)
2.3时间片轮转调度算法 (17)
2.3.1算法思想 (17)
2.3.2 算法流程图 (18)
2.3.3程序代码 (19)
2.3.4测试结果 (21)
2.4测试分析 (22)
总结 (23)
参考文献 (24)
进程调度算法的分析与研究
摘要
调度也称dispatcher 这是内核的主要职责之一就是决定该轮到哪个任务运行了多数实时内核是基于优先级调算法的每个任务根据其重要程度的不同被赋予一定的优先级基于优先级的调度法指CPU总是让处在就绪态的优先级最高的任务先运行然而究竟何时让高优先级任务掌握CPU的使用权有两种不同的情况这要看用的是什么类型的内核是非占先式还是占先式的内核。进程调度性能的衡量方法可以分为定性和定量两种，在定性衡量方面，首先是调度的安全性。比如，一次进程调度是否可能引起数据结构的破坏等。这要求对调度时机的选择和保存CPU现场十分小心。另外，系统开销也是衡量进程调度的一个重要指标，由于调度程序的执行涉及到多个进程的上下文切换，如果调度策略过于繁琐和复杂，将会耗去较大的系统开销。这在用户进程调度系统调用较多的情况下，将会造成响应时间大幅度增加。
进程调度的定量评价包括CPU的利用率评价、进程在就绪队列中的等待时间与执行时间之比等。实际上，由于进程进入就绪队列的随机模型很难确定，而且进程上下文切换等也将影响进程的执行效率，从而对进程调度进行解析是很困难的，一般情况下，大多利用模拟或测试系统响应时间的方法来评价进程调度的性能。本文详细地讨论了四种常用进程调度算法的基本思想，并对其进行了分析和评价。
关键词：进程算法分析研究
引言
进程调度是系统内部的低级调度，进程调度的策略通常有先来先服务算法、时间片轮转算法、最高优先权优先调度算法等。衡量进程调度性能通常需要从定性和定量两个方面来综合考虑。进程调度性能的衡量方法可以分为定性和定量两种，在定性衡量方面，首先是调度的安全性。比如，一次进程调度是否可能引起数据结构的破坏等。这要求对调度时机的选择和保存CPU现场十分小心。另外，系统开销也是衡量进程调度的一个重要指标，由于调度程序的执行涉及到多个进程的上下文切换，如果调度策略过于繁琐和复杂，将会耗去较大的系统开销。这在用户进程调度系统调用较多的情况下，将会造成响应时间大幅度增加。
进程调度的定量评价包括CPU的利用率评价、进程在就绪队列中的等待时间与执行时间之比等。实际上，由于进程进入就绪队列的随机模型很难确定，而且进程上下文切换等也将影响进程的执行效率，从而对进程调度进行解析是很困难的，一般情况下，大多利用模拟或测试系统响应时间的方法来评价进程调度的性能。
第一章进程概述
1.1进程调度
无论是在批处理系统还是分时系统中，用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。另外，系统进程也同样需要使用处理机。这就要求进程调度程序按一定的策略，动态地把处理机分配给处于就绪队列中的某一个进程，以使之执行。
1.1.1进程的属性
1、多态性从诞生、运行，直至消灭
2、多个不同的进程可以包括相同的程序
3、三种基本状态它们之间可进行转换
4、并发性并发执行的进程轮流占用处理器
1.1.2进程的基本状态
1、等待态：等待某个事件的完成；
2、就绪态：等待系统分配处理器以便运行；
3、运行态：占有处理器正在运行。
运行态→等待态往往是由于等待外设，等待主存等资源分配或等待人工干预而引起的。
等待态→就绪态则是等待的条件已满足，只需分配到处理器后就能运行。
运行态→就绪态不是由于自身原因，而是由外界原因使运行状态的进程让出处理器，这时候就变成就绪态。例如时间片用完，或有更高优先级的进程来抢占处理器等。
就绪态→运行态系统按某种策略选中就绪队列中的一个进程占用处理器，此时就变成了运行态。
1.2进程调度的三种算法
（1）先来先服务算法：如果早就绪的进程排在就绪队列的前面，迟就绪的进程排在就绪队列的后面，那么先来先服务总是把当前处于就绪队列之首的那个进程调度到运行状态。
（2）优先数算法：即进程的执行顺序由高优先级到低优先级。系统或用户按某种原则为进程指定一个优先级来表示该进程所享有的确调度优先权。该算法核心是确定进程的优先级。
（3）时间片轮转算法：固定时间片，每个进程在执行一个时间片后，轮到下一进程执行，知道所有的进程执行完毕。处理器同一个时间只能处理一个任务。处理器在处理多任务的时候，就要看请求的时间顺序，如果时间一致，就要进行预测。挑到一个任务后，需要若干步骤才能做完，这些步骤中有些需要处理器参与，有些不需要（如磁盘控制器的存储过程）。不需要处理器处理的时候，这部分时间就要分配给其他的进程。原来的进程就要处于等待的时间段上。经过周密分配时间，宏观上就象是多个任务一起运行一样，但微观上是有先后的，就是时间片轮换。
第二章算法分析
2.1先来先服务调度算法
2.1.1算法思想
先来先服务调度算法的思想是按照进程进入就绪队列的先后顺序调度并分配处理机执行。先来先服务调度算法是一种不可抢占的算法，先进入就绪队列的进程，先被处理机运行。一旦一个进程占有了处理机，它就一直运行下去，直到该进程完成工作或者因为等待某事件而不能继续运行时才释放处理机。
2.1.2 算法流程图
图2—1先来先服务算法流程图
2.1.3 程序代码
#include
#include
#include
typedef struct node
{
char name[10]; /*进程名*/
int cputime; /*占用cpu时间*/
char starttime[5]; //进程开始时间
int needtime; /*要求运行时间*/
char state; /*状态*/
struct node *next; /*指针*/
}PCB;
PCB *ready, *run, *finish; //就绪、执行、结束指针
int N; //进程数量
void print() //输出函数
{
PCB *p;
printf(" NAME CPUTIME STARTTIME NEEDTIME STA TUS\n");
if(run != NULL)
printf(" %-10s%-10d%-10s%-10d %c\n",
run->name,
run->cputime,
run->starttime,
run->needtime,
run->state); /*输出执行的进程的信息*/
p=ready;
while(p != NULL)
{
printf(" %-10s%-10d%-10s%-10d %c\n",
p->name,
p->cputime,
p->starttime,
p->needtime,
p->state); /*输出就绪进程的信息*/
p=p->next;
}
p=finish;
while(p != NULL)
{
printf(" %-10s%-10d%-10s%-10d %c\n",
p->name,
p->cputime,
p->starttime,
p->needtime,
p->state); /*输出结束队列的信息*/
p=p->next;
}
getchar(); /*使用getchar()函数可以让输出时停留画面，
等待人按回车继续*/
}
void insert(PCB *q) /*插入新进程，把进程按进程到来时间大小排序*/
{
PCB *p1,*s,*r;
int b;
s=q; /*指针s指向新要插入的进程*/
p1=ready; /*指针p1指向原来的进程队列的队首*/
r=p1; /*使用指针r是指向p1前面的进程*/
b=1;
while((p1!=NULL)&&b)
if(strcmp(p1->starttime,s->starttime)<0)
{
r=p1; p1=p1->next;
} /*新进程的开始时间大，则p1 指向下一个进程继续比*/
else
b=0;
if(r!=p1)
{
r->next=s; s->next=p1;
} /*新进程找到位置，插在r和p1之间*/
else
{
s->next=p1; ready=s;
} /*新进程的开始时间按最小，插在队首，并修改就绪队首ready指针*/ }
void create()
{
PCB *p;
int i;
ready=NULL;
run=NULL;
finish=NULL;
printf("Please enter the name and time and starttime of PCB:\n");
/*输入进程名、运行时间和开始时间*/
for(i=0;i { p=(PCB *)malloc(sizeof(PCB)); /*为新进程开辟空间*/ scanf("%s",p->name); /*输入进程名*/ scanf("%d",&p->needtime); /*输入进程要求运行时间*/ scanf("%s",p->starttime); //输入进程开始时间 p->cputime=0; p->state='W'; /*表示就绪队列中未在队首先执行，但也是就绪状态*/ if (ready!=NULL) insert(p); /*就绪队首不为NULL，插入新进程*/ else { /*否则先插在NULL前*/ p->next=ready; ready=p; } } printf(" Display is going to start: \n"); printf("***********************************************\n"); print(); getchar(); run=ready; /*队列排好，run指向就绪队列队首*/ ready=ready->next; /*ready指向下一个进程*/ run->state='R'; /*队首进程的状态为就绪*/ } void FCFS() { while(run != NULL) { run->cputime=run->cputime+run->needtime; run->needtime=0; run->next=finish; finish = run; run->state='E'; run = NULL; if(ready != NULL) { run = ready; run->state='R'; ready=ready->next; } print(); } } void main() { printf("Please enter the total number of PCB:\n"); scanf("%d",&N); create(); /*模拟创建进程，并输入相关信息*/ FCFS(); /*先来先服务调度算法*/ } 2.1.4测试结果 首先输入进程个数（为5个），这里命名为A,B,C,D,E，然后分别输入运行时间和开始时间 所有进程都在队列中，并都处于等待状态 其中一个进程执行完毕 所有进程都执行完毕 2.2优先数调度算法 2.2.1算法思想 进程的执行顺序由高优先级到低优先级，系统或用户按某种原则为进程指定一个优先级来表示该进程所享有的确调度优先权。该算法核心是确定进程的优先 级。 2.2.2算法流程图 图2—2优先数算法流程图 2.2.3程序代码 #include #include #include typedef struct node { char name[10]; /*进程名*/ int prio; /*优先数*/ int cputime; /*占用cpu时间*/ int needtime; /*要求运行时间*/ char state; /*状态*/ struct node *next; /*指针*/ }PCB; PCB *ready,*run,*finish; /*就绪执行结束指针*/ int N; void prt() /*输出函数，可以方便看到进程执行的演示*/ { PCB *p; printf(" NAME CPUTIME NEEDTIME PRIORITY STATUS\n"); if(run!=NULL) printf(" %-10s%-10d%-10d%-10d %c\n",run->name,run->cputime,run->need time,run->prio,run->state); /*输出执行的进程的信息*/ p=ready; while(p!=NULL) {printf(" %-10s%-10d%-10d%-10d %c\n",p->name,p->cputime,p->needtime, p->prio,p->state); /*输出就绪进程的信息*/ p=p->next; } p=finish; while(p!=NULL) { printf(" %-10s%-10d%-10d%-10d %c\n",p->name,p->cputime,p->needtim e,p->prio,p->state); /*输出结束队列的信息*/ p=p->next; } getchar(); } /*使用getchar()函数可以让输出时停留画面，等待人按回车继续*/ void insert(PCB *q) /*插入新进程，把进程按优先数大小排序*/ { PCB *p1,*s,*r; int b; s=q; /*指针s指向新要插入的进程*/ p1=ready; /*指针p1指向原来的进程队列的队首*/ r=p1; /*使用指针r是指向p1前面的进程*/ b=1; while((p1!=NULL)&&b) if(p1->prio>=s->prio) { r=p1; p1=p1->next; } /*新进程的优先数小，则p1 指向下一个进程继续比*/ else b=0; if(r!=p1) { r->next=s; s->next=p1; } /*新进程找到位置，插在r和 p1之间*/ else { s->next=p1; ready=s; } } /*新进程的优先数最大，插在队首，并 修改就绪队首ready指针*/ void create() { PCB *p; int i; ready=NULL; run=NULL; finish=NULL; printf("Please enter the name and time and priority of PCB:\n"); /*输入进程名、运行时间和优先级*/ for(i=0;i { p=(PCB *)malloc(sizeof(PCB)); /*为新进程开辟空间*/ scanf("%s",p->name); /*输入进程名*/ scanf("%d",&p->needtime); /*输入进程要求运行时间*/ scanf("%d",&p->prio); /*输入进程优先数*/ p->cputime=0; p->state='W'; /*表示就绪队列中未在队首先执行，但也是就绪状 态*/ if (ready!=NULL) insert(p); /*就绪队首不为NULL，插入新进程 */ else { p->next=ready; ready=p; } } /*否则先插在NULL前*/ printf(" Display is going to start: \n"); printf("***********************************************\n"); prt(); run=ready; /*队列排好，run指向就绪队列队首*/ ready=ready->next; /*ready指向下一个进程，这样当进程执行时如 果优先数小于其他的进程，应该先进行优先数最大的进程*/ run->state='R'; } /*队首进程的状态为就绪*/ void prio() { while(run!=NULL) { run->cputime=run->cputime+1; /*运行一次cpu占用时间加一*/ run->needtime=run->needtime-1; /*运行一次要求运行时间减一*/ run->prio=run->prio-1; /*运行一次优先数减一*/ if(run->needtime==0) /*若要求运行时间为0时*/ { run->next=finish; /*退出队列*/ finish=run; /*finish为结束进程的队列 */ run->state='E'; /*修改状态为结束*/ run=NULL; /*释放run指针*/ if (ready!=NULL) /*创建新就绪队列的头指针*/ { run=ready; run->state='R'; ready=ready->next; } } else if((ready!=NULL)&&(run->prio /*队首进程的优先数比它下一个小，且下一个进程不为NULL时执行*/ { run->state='W'; run->next=NULL; /*队首进程退出进程队列*/ insert(run); /*在进程队列中重新插入原来的队首进程*/ run=ready; /*重新置就绪队列的头指针*/ run->state='R'; ready=ready->next; } prt(); } } void main() { printf("Please enter the total number of PCB:\n"); scanf("%d",&N); create(); /*模拟创建进程，并输入相关信息*/ prio(); } /*优先数调度算法*/ 2.2.4测试结果 优先级调度算法运行情况如图2—3，图2—4，图2—5，图2—6所示 图2—3输入进程块的数量 图2—4输入每个进程的名称、时间、优先级 图2—5输入所有的进程的相关信息 图2—6所有进程调度算法完成 2.3时间片轮转调度算法 2.3.1算法思想 所有就绪进程按先来先服务的原则排成一个队列，将新来的进程加到就绪对列的末尾，每当执行进程调度时，总是把处理机分配给队首的进程，各进程占用CPU的时间片相同。也就是说CPU的处理时间划分成一个个相同的时间片，就绪 队列的所有进程轮流运行一个时间片。当一个时间片结束时，如果运行进程用完它的时间片后还未完成，就强迫运行进程让出CPU，就把它送回到就绪队列的末尾，等待下一次调度。同时，进程调度又去选择就绪队列中的队首进程，分配给它一时间片，以投入运行。直至所有的进程运行完毕。 2.3.2 算法流程图 图2—7优先数算法流程图 2.3.3程序代码 #include #include #include typedef struct node { char name[10]; /*进程名*/ int count; /*计数器，判断是否=时间片的大小*/ int cputime; /*占用cpu时间*/ int needtime; /*要求运行时间*/ char state; /*状态*/ struct node *next; /*指针*/ }PCB; PCB *ready,*run,*finish,*tail; /*就绪执行结束尾指针*/ int N,round; void prt() /*输出函数，可以方便看到进程执行的演示*/ { PCB *p; printf(" NAME CPUTIME NEEDTIME STA TUS\n"); if(run!=NULL) printf(" %-10s%-10d%-10d %c\n",run->name,run->cputime,run->needtime,run->state); /*输出执行的进程的信息*/ p=ready; while(p!=NULL) { printf(" %-10s%-10d%-10d %c\n",p->name,p->cputime,p->needtime,p->state); /*输出就绪进程的信息*/ p=p->next; } p=finish; while(p!=NULL) { printf(" %-10s%-10d%-10d %c\n",p->name,p->cputime,p->needtime,p->state); /*输出结束队列的信息*/ p=p->next; } getchar(); } void insert(PCB *q) /*在队尾插入新的进程*/ { PCB *p; p=ready; while(p->next!=NULL) { p=ready->next; } tail=p; tail->next=q; q->next=NULL; } void create() { PCB *p; int i; ready=NULL; run=NULL; finish=NULL; printf("Please enter the name and time of PCB:\n"); /*输入进程名、和*/ for(i=0;i { p=(PCB *)malloc(sizeof(PCB)); /*为新进程开辟空间*/ scanf("%s",p->name); /*输入进程名*/ scanf("%d",&p->needtime); /*输入进程要求运行时间*/ p->cputime=0; p->state='W'; /*表示就绪队列中未在队首先执行，但也是就绪状态*/ if (ready!=NULL) insert(p); /*就绪队首不为NULL，插入新进程*/ else { p->next=ready; ready=p; tail=p; } } printf(" Display is going to start: \n"); printf("***********************************************\n"); prt(); getchar(); run=ready; /*队列排好，run指向就绪队列队首*/ ready=ready->next; /*ready指向下一个进程*/ run->state='R'; } /*队首进程的状态为就绪*/ void count() { while(run!=NULL) { run->cputime=run->cputime+1; /*运行一次cpu占用时间加一*/ run->needtime=run->needtime-1; /*运行一次要求运行时间减一*/ run->count=run->count+1; /*运行一次计数器加一*/ if(run->needtime==0) /*若要求运行时间为0时*/ { 计算机操作系统进程调度实验研究报告 ————————————————————————————————作者：————————————————————————————————日期： 操作系统实验题：设计一若干并发进程的进程调度程序 一、实验目的 无论是批处理系统、分时系统还是实时系统，用户进程数一般都大于处理机数，这将导致用户进程互相争夺处理机。这就要求进程调度程序按一定的策略，动态地把处理及分配给处于就绪队列中的某一进程，以使之执行。进程调度是处理机管理的核心内容。本实验要求采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法编写和调试一个简单的进程调度程序。通过本实验可以加深理解有关进程控制块、进程队列的概念。并体会了优先数和先来先服务调度算法的具体实施办法。 二、实验要求 用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解． 三、实验内容 进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法（将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列，并按照先来先服务的方式进行调度处理）。 每个进程有一个进程控制块（PCB）表示。进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。 进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。 进程的运行时间以时间片为单位进行计算。 每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。 就绪进程获得CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。 如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。 每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。重复以上过程，直到所要进程都完成为止。 四、实验算法流程 《操作系统原理》实验报告 实验名称：Linux随机进程调度算法实现 班级： 学号： 姓名： 日期： 2012/12/31 一、实验名称 Linux随机进程调度算法实现 二、所属课程名称 《操作系统原理》 三、实验原理 linux 0.11内核目录linux/kernel中的sched.c函数是内核中进程调度管理的程序，其中schedule()函数负责选择系统中下一个要运行的进程。 schedule()函数首先对所有任务（进程）进行检测，唤醒任何一个已经得到信号的进程。具体方法是任务数组中的每个进程，检查其报警定时值alarm。如果进程的alarm时间已经过期（alarm NR_TASKS：系统能容纳的最大进程数(64个)； task[]：任务（进程）数组； 更改代码如下：（linux 0.11内核目录下linux/kernel/sched.c 源文件的scheduling（）函数while（1）循环）while (1) { //定义c用来判断系统中是否可运行的任务（进程）存在; c=-1; //c初值设为-1，默认不存在可运行进程; next = 0;//next记录下一个即将运行的进程; i=jiffies % NR_TASKS+1; //i的值是随机产生的; p=&task[i];//p指向在task表中下标为i的进程； while (--i) { //遍历task[]； if(!*--p)continue; //如果task[i]不包含进程，跳过； //如果task[i]包含进程且该进程处于就绪状态，记录 //该任务（进程）序号，跳出无限循环while(1),转向 //switch_to()函数执行该任务（进程）； if ((*p)->state == TASK_RUNNING) { next = i; c=i; break; } } if (c) break;//如果没有任何任务(进程)要执行，则跳出， //转向switch_to()，执行0号进程(idle)。 } 进程调度算法实验报告 篇一：操作系统进程调度算法模拟实验报告 进程调度算法模拟 专业：XXXXX 学号：XXXXX 姓名：XXX 实验日期：20XX年XX月XX日 一、实验目的 通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。 二、实验要求 编写程序实现对5个进程的调度模拟，要求至少采用两种不同的调度算 法分别进行模拟调度。 三、实验方法内容 1. 算法设计思路 将每个进程抽象成一个控制块PCB， PCB用一个结构体描述。 构建一个进程调度类。将进程调度的各种算法分装在一个类中。类中存 在三个容器，一个保存正在或未进入就绪队列的进程，一个保存就绪的进程，另一个保存已完成的进程。还有一个PCB实例。主要保存正在运行的进程。类中其他方法都是围绕这三个容器可以这个运行中的PCB展开。 主要用到的技术是STL中的vector以维护和保存进程容器、就绪容器、 完成容器。 当程序启动时，用户可以选择不同的调度算法。然后用户从控制台输入 各个进程的信息，这些信息保存到进程容器中。进程信息输入完毕后，就开始了进程调度，每调度一次判断就绪队列是否为空，若为空则系统时间加一个时间片。判断进程容器中是否有新的进程可以加入就绪队列。 2. 算法流程图主程序的框架： ();//先来先服务 ();//最短进程优先调度//简单时间片轮转//最高优先数优先//输入进程信息 ();.m_WaitQueue.empty()||.m_ProcessQueue.empt() (); (); 进程调度过程： ; 3. 算法中用到的数据结构 struct fcfs{//先来先服务算法从这里开始char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;float 长沙学院课程设计说明书 题目进程调度程序设计 系(部) 计算机科学与技术系 专业(班级) 2009级数据库二班 姓名 学号 指导教师黄彩霞 起止日期2012．6．4-2012．6．15 课程设计任务书 课程名称：操作系统课程设计 设计题目：进程调度程序设计 已知技术参数和设计要求： 1. 设计任务 设计一个虚拟内核，该内核能支持多任务管理。提供创建进程、终止进程、进程状态转换，进程调度，上下文切换等功能。 2. 问题描述 2.1 系统组成 系统由虚拟内核(VKernel)、命令解释程序(Commander)、用户程序（Application）、编译器（Compiler）四部分组成。VKernel首先运行，并常驻内存。Kernel启动后，创建Commander进程。根据用户请求创建多个Application进程。Kernel负责维护6个数据结构，包括时间 (Time), 处理器状态(CPUstate),进程表(PCBTable), 就绪队列(ReadyState),等待队列(BlockedState),运行进程（RunningState）。Time是系统时间片。CPUstate应包括程序计数器PC,累加器A、B,状态寄存器F的值。PCBTable的每一项是一个进程的进程控制块(PCB)。Commander程序、Application程序是用下列CPU虚拟指令书写的程序： ①CPU虚拟指令(以下指令仅供参考, 设计者可以自行设计) MOV n //把整数n赋给累加器A SAV m //把累加器A的值存入地址M ADD n //从累加器A的值减去整数n，结果送到累加器A。 SUB n //从累加器A的值减去整数n，结果送到累加器A。 MUL n //从累加器A的值乘以整数n，结果送到累加器A。 DIV n //从累加器A的值除以整数n，结果送到累加器A。 JEQ m //F为0跳转到m JLG m //F大于0跳转到m JLE m //F大于等于0跳转到m JMP m //无条件跳转到m OUT port //累加器的内容输出到端口port。port为0，指显示器；为1，指扬声器。 ②虚拟系统调用(以下系统调用仅供参考, 设计者可自行设计) exec() //执行程序并创建子进程 exit() //进程终止 block() //进程等待 printk() //在屏幕上打印系统信息 作业调度 一、实验名称 作业调度算法 二、实验目标 在单道环境下编写作业调度的模拟程序，以加深对作业调度的理解。单道环境的特点使被调度的作业占有所有的资源。实现的算法有先来先服务，最短作业优先，最高响应比三种作业调度算法。 三、实验环境要求： 1.PC机。 2.Windows； 3.CodeBlocks 四、实验基本原理 1.本实验设计一个可指定作业个数的作业调度系统。可以输出先来先服务，最短作业优先，最高响应比三种作业调度算法的结果。 2.先来先服务就是按照各个作业进入系统的自然次序进行调度。最短作业优先就是优先调度并且处理短作业。最高响应比优先就是根据在程序运行过程中的最高响应比对应的作业先进行调度处理。 3.在设计程序过程中，将time相关的内容封装到类中，重载了加减乘除和输入输出以及比较运算符，方便12:00这种形式的数据的加减乘除运算和比较运算， 五、数据结构设计 1.时间类 class time { public: time(int x = 0, int y = 0) { time::hour = x; time::minute = y; } time& operator = (const time &t1) { this->hour=t1.hour; this->minute=t1.minute; return *this; } time operator + (time t2) { intminutes,hours; minutes = (minute + t2.minute) % 60; hours=hour+t2.hour+ (minute + t2.minute) /60; return time(hours,minutes); } time operator -(time t2) { intminutes,hours; minutes =minute - t2.minute; if (minute<0) { minutes += 60; hour--; } 课程设计报告 题 目 进程调度程序设计 课 程 名 称 操作系统课程设计 院 部 名 称 计算机工程学院 专 业 计算机科学与技术 班 级 13计算机科学与技术(单)(1) 学 生 姓 名 周敏健 学 号 1305201013 课程设计地点 A104 课程设计学时 20学时 指 导 教 师 何 健 金陵科技学院教务处制 成绩 目录 摘要 (3) 一、课程设计的目的和要求 (4) 二、系统需求分析 (4) 三、总体设计 (5) 四、详细设计 (6) 五、测试、调试过程 (9) 六、结论与体会 (11) 七、参考文献 (12) 附录：源程序 (12) 课程设计课题 进程调度程序设计 摘要 在多道系统中，对批处理作业需要进行作业调度。作业调度是在资源满足的条件下，将处于就绪状态的作业调入内存，同时生成与作业相对应的进程，并未这些进程提供所需要的资源。进程调度需要根据进程控制块（PCB）中的信息，检查系统是否满足进程的资源需求。只有在满足进程的资源需求的情况下，系统才能进行进程调度。下面是几种常见的作业调度算法：先来先服务（FCFS）、优先算法、轮换算法、短作业优先算法以及最高响应比优先法等，本文将对前两种算法进行详细的介绍。 关键词：进程调度，优先级，FCFS，PCB，作业，资源 一、课程设计的目的和要求 1、目的 进程调度是处理机管理的核心内容。本设计要求用C语言编写和调试一个简单的进程调度程序。通过设计本可以加深理解有关进程控制块、进程队列的概念，并体会和了解最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法的具体实施办法。 2、要求 1）进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。 2）每个进程有一个进程控制块（PCB）表示。进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。 3）进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。进程的运行时间以时间片为单位进行计算。 4）每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。 5）就绪进程获得CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。 6）每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。 7）重复以上过程，直到所要进程都完成为止。 二、系统需求分析 编写一个模拟进程调度的程序，将每个进程抽象成一个进程控制块PCB，PCB 用一个结构体描述。 采用两种不同的调度算法来实现功能，主要有如下几大功能模块组成。 （1）创建优先数PCB模块 进程调度函数schedule()分析 一．主要功能： 实现进程的调度，从运行队列的链表中找到一个进程，然后进行分配。可以由几个内核控制路径调用。 二．调用方式： 1.当前进程不能获得必要资源而被阻塞，可以直接调用schedule()。将current进程插入 适当的等待队列，把状态改为TASK_INTERRUPTABLE或TASK_UNINTERRUPTABLE，然后调用schedule()。一旦资源可用，就从等待队列删除current进程。 2.把current进程的TIF_NEED_RESCHED标志设置为1，由于会在恢复前检查这个标志的 值，所以schedule()将在之后某个时间被明确调用，以延迟方式调用调度程序。 三. 功能分析： asmlinkage void schedule(void) { struct schedule_data * sched_data; struct task_struct *prev, *next, *p; struct list_head *tmp; int this_cpu, c; //定义变量，*prev为调度之前进程，*next为调度之后进程 spin_lock_prefetch(&runqueue_lock); BUG_ON(!current->active_mm);//current进程的active_mm为空，出错 need_reshced_back; prev=current;//变量初始化 this_cpu = prev->processor; (unlikely(in_interrupt())) { printk("Scheduling in interrupt\n"); BUG(); }//不能再中断程序中执行schedule()，否则会出错 release_kernel_lock(prev, this_cpu); sched_data = & aligned_data[this_cpu].schedule_data; spin_lock_irq(&runqueue_lock);//释放内核锁，开this_cpu中断，并锁住runqueue队列/* move an exhausted RR process to be last.. */ if (unlikely(prev->policy == SCHED_RR))//是否为轮转调度 if (!prev->counter) { prev->counter = NICE_TO_TICKS(prev->nice); move_last_runqueue(prev); }//prev->counter为逐渐减少的进程时间配额，当为0时就从当前位置到runqueue 的末尾。NICE_TO_TICKS将优先级别换算为时间配额，即恢复开始的时间配额switch (prev->state) { case TASK_INTERRUPTIBLE: if (signal_pending(prev)) { prev->state = TASK_RUNNING; break; }//查看当前状态，如果处于TASK_INTERRUPTIBLE且有信号等待处理，内核将状态设置为TASK_RUNNING,让其处理完 操作系统实验报告（二） 实验题目：进程调度算法 实验环境：C++ 实验目的：编程模拟实现几种常见的进程调度算法，通过对几组进程分别使用不同的调度算法，计算进程的平均周转时间和平均带权周转时间，比较 各种算法的性能优劣。 实验内容：编程实现如下算法： 1.先来先服务算法； 2.短进程优先算法； 3.时间片轮转调度算法。 设计分析： 程序流程图： 1.先来先服务算法 开始 初始化PCB，输入进程信息 各进程按先来先到的顺序进入就绪队列 结束 就绪队列？ 运行 运行进程所需CPU时间 取消该进程 2.短进程优先算法 3.时间片轮转调度算法 实验代码： 1.先来先服务算法 #include int atime; //进程到达时间 int runtime; //进程运行时间 }fcs; void main() { int amount,i,j,diao,huan; fcs f[n]; cout<<"请输入进程个数:"< 课程名称：实验项目：实验地点： 专业班级：学生姓名：指导教师： 本科实验报告 操作系统B 进程调度程序设计 学号：2011 年11 月 目录 进程调度程序设计 一、实验目的和要求 (1) 二、实验内容及原理 (1) 三、实验仪器设备 (3) 四、操作方法与实验步骤 (3) 五、实验数据记录和处理 (3) 六、实验结果与分析 (10) 七、实验感想 (11) 实验二 一、实验目的和要求 （一） 目的 进程调度程序设计 进程是操作系统最重要的概念之一，进程调度是操作系统的主要内容，本实验要求 学生独立地用高级语言编写一个进程调度程序，调度算法可任意选择或自行设计，本实验 可使学生加深对进程调度和各种调度算法的理解。 （二） 要求 1． 设计一个有几个进程并发执行的进程调度程序，每个进程由一个进程控制块(PCB) 表示，进程控制块通常应包括下述信息：进程名，进程优先数，进程需要运行的时间，占 用 CPU 的时间以及进程的状态等，且可按照调度算法的不同而增删。 2． 调度程序应包含 2—3 种不同的调度算法，运行时可以任选一种，以利于各种方法 的分析和比较。 3． 系统应能显示或打印各进程状态和参数的变化情况，便于观察。 二、实验内容及原理 1． 本程序可选用优先数法或简单轮转法对五个进程进行调度。每个进程处于运行 R(run)、就绪 W(wait)和完成 F(finish)三种状态之一，并假定起始状态都是就绪状态 W 。 为了便于处理，程序中进程的运行时间以时间片为单位计算。各进程的优先数或轮 转时间片数、以及进程需要运行的时间片数，均由伪随机数发生器产生。 进程控制块结构如表 2-1 所示： 表 2-1 PCB 进程控制块链结构如图 2-1 所示： 图 2-1 进程控制块链结构 其中：RUN —当前运行进程指针； 进程标识符 链指针 优先数/轮转时间片数 占用 CPU 时间片数 进程所需时间片数 进程状态 摘要 多核操作系统已经被广泛应用到我们的日常生活，并让我们的生活更加丰富多彩,系统增加了处理器的数量，这允许以最大化系统任务来分配处理器的性能。最初，系统中只有一个处理器,在处理器中不用考虑进程的分布，只要根据其他标准作出判断，现在增加了一个非常重要的因素，原标准必须调整到新的标准.而有些CPU在处理器中闲置，有些过载,有必要进行适当的调整，以最大限度地提高整个系统的CPU利用率。如何找到这些不平衡在外观上如何调整，为了使实施的总时间最小，Cache获得更多使用，这将是本文的重点，从调度到优化系统的性能。 本课题试图分析Linux内核源代码,调度工作原理和规划进程的流程，在此基础上改进系统。本文主要讨论基于Linux的多芯片SMP的定时进程调度系统，主要内容包括: 1. 研究进程管理调度基本原理； 2. 分析定时任务调度系统,研究时间片轮转调度机制及优先级计算; 3。在ubuntu系统下实现上面的进程调度程序。 关键词： linux 进程调度分时任务时间片轮转优先级 ABSTRACT Multi—core operating systems have been widely used in our daily lives，and make our lives more colorful，the system increases the number of processors，which allows to maximize the system tasks to allocate processor performance。Initially，there is only one processor in the system，in the processor do not consider the distribution of the process，as long as the other criteria to make judgments, now add a very important factor, the original standard must be adjusted to the new standard。And some CPU in the processor idle，some overload, it is necessary to make appropriate adjustments to maximize the overall system CPU utilization。How to find these imbalances in how to adjust，in order to make the implementation of the total time minimum, Cache get more use, it will be the focus of this article, from scheduling to optimize the system performance. This topic attempts to analyze the Linux kernel source code, scheduling the working principle and planning process of the process, on the basis of improving the system. This paper mainly discusses the multi-chip SMP timing scheduling system based on Linux, the main contents include： 1。Research process management scheduling basic principles; 1。Analyze the timing task scheduling system，study the time slice rotation scheduling mechanism and priority calculation； 3. Under ubuntu system to achieve the above process scheduler. KEY WORDS:Linux process scheduling time —sharing task time sheet rotation priority 一．课程概述 1.1.设计构想 程序能够完成以下操作：创建进程：先输入进程的数目，再一次输入每个进程的进程名、运行总时间和优先级，先到达的先输入；进程调度：进程创建完成后就选择进程调度算法，并单步执行，每次执行的结果都从屏幕上输出来。 1.2.需求分析 在多道程序环境下，主存中有着多个进程，其数目往往多于处理机数目，要使这多个进程能够并发地执行，这就要求系统能按某种算法，动态地把处理机分配给就绪队列中的一个进程，使之执行。分配处理机的任务是由处理机调度程序完成的。由于处理机是最重要的计算机资源，提高处理机的利用率及改善系统必（吞吐量、响应时间），在很大程度上取决于处理机调度性能的好坏，因而，处理机调度便成为操作系统设计的中心问题之一。本次实验在VC++6.0环境下实现先来先服务调度算法，短作业优先调度算法，高优先权调度算法，时间片轮转调度算法和多级反馈队列调度算法。 1.3.理论依据 为了描述和管制进程的运行，系统为每个进程定义了一个数据结构——进程控制块PCB(Process Control Block),PCB中记录了操作系统所需的、用于描述进程的当前情况以及控制进程运行的全部信息，系统总是通过PCB对进程进行控制，亦即，系统是根据进程的PCB 而不是任何别的什么而感知进程的存在的，PCB是进程存在的惟一标志。本次课程设计用结构体Process代替PCB的功能。 1.4.课程任务 一、用C语言（或C++）编程实现操作模拟操作系统进程调度子系统的基本功能；运用多 种算法实现对进程的模拟调度。 二、通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转、短作业优先、多 级反馈队列调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。 三、实现用户界面的开发 一、实验目的 通过对进程调度算法的设计，深入理解进程调度的原理。 进程是程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位。 进程调度分配处理机，是控制协调进程对CPU的竞争，即按一定的调度算法从就绪队列中选中一个进程，把CPU的使用权交给被选中的进程。 进程通过定义一个进程控制块的数据结构（PCB）来表示；每个进程需要赋予进程ID、进程到达时间、进程需要运行的总时间的属性；在RR中，以1为时间片单位；运行时，输入若干个进程序列，按照时间片输出其执行序列。 二、实验环境 VC++6.0 三、实验内容 实现短进程优先调度算法（SPF）和时间片轮转调度算法（RR） [提示]： (1) 先来先服务（FCFS）调度算法 原理：每次调度是从就绪队列中，选择一个最先进入就绪队列的进程，把处理器分配给该进程，使之得到执行。该进程一旦占有了处理器，它就一直运行下去，直到该进程完成或因发生事件而阻塞，才退出处理器。 将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列，并按照先来先服务的方式进行调度处理，是一种最普遍和最简单的方法。它优先考虑在系统中等待时间最长的作业，而不管要求运行时间的长短。 按照就绪进程进入就绪队列的先后次序进行调度，简单易实现，利于长进程，CPU繁忙型作业，不利于短进程，排队时间相对过长。 (2) 时间片轮转调度算法RR 原理：时间片轮转法主要用于进程调度。采用此算法的系统，其程序就绪队列往往按进程到达的时间来排序。进程调度按一定时间片（q）轮番运行各个进程. 进程按到达时间在就绪队列中排队，调度程序每次把CPU分配给就绪队列首进程使用一个时间片，运行完一个时间片释放CPU，排到就绪队列末尾参加下一轮调度，CPU分配给就绪队列的首进程。 固定时间片轮转法： 1 所有就绪进程按 FCFS 规则排队。 2 处理机总是分配给就绪队列的队首进程。 3 如果运行的进程用完时间片，则系统就把该进程送回就绪队列的队尾，重新排队。 4 因等待某事件而阻塞的进程送到阻塞队列。 5 系统把被唤醒的进程送到就绪队列的队尾。 可变时间片轮转法： 1 进程状态的转换方法同固定时间片轮转法。 2 响应时间固定，时间片的长短依据进程数量的多少由T = N × （ q + t ）给出的关系调整。 3 根据进程优先级的高低进一步调整时间片，优先级越高的进程，分配的时间片越长。 多就绪队列轮转法： (3) 算法类型 (4)模拟程序可由两部分组成，先来先服务（FCFS）调度算法，时间片轮转。流程图如下: 管理学的研究现状及其发展趋势分析 李传军 （中国人民大学公共管理学院北京100872） 摘要：从理论上总结管理学的研究现状，并结合管理实践预测其发展趋势，对于管理学科的发展有着十分重要的意义。国外管理学的发展已经较为成熟，目前的研究主要集中于管理主体（组织）、管理方法（工具）、管理对象（人和物）等方面；而我国管理学尚处于理论建构阶段，对于管理学学科体系尚存在不同的意见。近年来，随着管理实践的发展，管理学呈现出以下明显的趋势：管理学在科学体系中的地位将进一步提高；管理学发展的理论化、哲学化趋势；新的管理学分支的发展将更加迅速；管理学将更多地与经济学、心理学、社会学、数学等紧密地结合；管理学研究将更加突出以人为本的特色；理论与实践的结合更加紧密。 一、管理学的研究现状 管理学发展到今天，尽管管理理论的各个学派在建构各自的理论体系时所采用的研究方法与技巧各有千秋，但它们之间并不存在明显的冲突，甚至互有借鉴。它们的终极目标都是为了组织的发展，并且是在系统思想的指导下，通过人力资源的深层挖掘去提高效率增加效益。 管理学研究的目的是为了促进组织的发展，为了组织适应环境的变化。组织要在变化的环境和激烈的竞争中求生存谋发展，就必须努力提高效率和增加效益。正是基于这一点，各管理学派都在努力寻找更有利于组织发展的途径，从不同的角度出发，采用了在它们看来完全合乎理性的各种假设，展开论述：古典管理理论第一次把管理作为一个科学领域进行研究，它对理论的主要过程、管理的职能和技能的论述在今天仍是大家的共识，并指导着管理的实践；组织行为科学理论学派对激励诱导、群体及组织内人际关系作了详细论述，确定了工人是有价值的资源；管理科学学派运用数学模式和程序求得决策和解决问题的最佳方案，特别是运用最新的信息情报系统，大大促进了管理效率的提高；决策学派注重效果，它从“效果”出发，充分考虑实现“效率”的最大化，并认为效率是实现效果的必要条件；经验管理学派则试图通过成功与失败的实例分析，寻找在同类条件下如何有效管理的方式，认为一个有效的组织必须以管理者的有效性为基础，而且管理者的有效性本身是对组织发展的最重要的贡献；系统管理理论强调系统分析和系统管理，认为系统管理有助于提高企业的效率和效果；权变管理理论则提出根据不同情况随机应变，从而使管理更为有效。 在管理方法方面，体现出显著的量化特征。就决策工具而言，它必须能够实际做出或建议做出决策，将真实世界中现有的那些种类的经验数据作为它们的输入，用量化的方法做出评估。在这种严格条件下的模型设计，选择了两个方向：第一个方向是保留最优化；第二个方向是设计满足模型，以合理的计算成本提供足够好的决策。这两个方向共存于管理理论的世界中，不论组织行为理论、决策理论，还是后起的系统分析学派、选择学派有、权变理论，都不同程度地在这两个方向徘徊。 关于人在组织中作用的认识，是管理理论在构建理论体系的过程中所无法回避的问题。传统管理理论将重点放在对“事”和“物”的管理上，漠视个人的需要和个人目标，从而看不到人的主动性和创造性。当然，这并不是说科学管理学派完全走向了人作为“经济人”的极端，事实上，不仅科学管理学派中的甘特、吉尔布雷斯等人有较多关于重视人的价值的论述，就是泰罗本人关于“精神革命”和培训工人的见解，以及雇主应以平等态度对待工人并了解其真实思想与感情的主张，都表明了他还是注意到了人这一因素。行为科学理论正是为了弥补传统管理理论的不足，把人的因素放在首位，并吸收了心理学、社会学中的许多理论 进程调度算法（附录）#include void display(pcb *p) { cout<<"name"<<" "<<"cputime"<<" "<<"needtime"<<" "<<"priority"<<" "<<"state"< 河南中医学院 《linux操作系统》课程设计报告 题目：基于Linux的进程调度模拟程序 所在院系：信息技术学院 专业年级：2011级计算机科学与技术完成学生：2011180021 郭姗 指导教师：阮晓龙 完成日期：201X 年06 月22 日 目录 1. 课程设计题目概述3 2. 研究内容与目的4 3. 研究方法5 4. 研究报告6 5. 测试报告/实验报告7 6. 课题研究结论8 7. 总结9 1、课程设计题目概述 随着Linux系统的逐渐推广，它被越来越多的计算机用户所了解和应用. Linux是一个多任务的操作系统，也就是说，在同一个时间内，可以有多个进程同时执行。如果读者对计算机硬件体系有一定了解的话，会知道我们大家常用的单CPU计算机实际上在一个时间片断内只能执行一条指令，那么Linux是如何实现多进程同时执行的呢？原来Linux使用了一种称为"进程调度（process scheduling）"的手段，首先，为每个进程指派一定的运行时间，这个时间通常很短，短到以毫秒为单位，然后依照某种规则，从众多进程中挑选一个投入运行，其他的进程暂时等待，当正在运行的那个进程时间耗尽，或执行完毕退出，或因某种原因暂停，Linux就会重新进行调度，挑选下一个进程投入运行。因为每个进程占用的时间片都很短，在我们使用者的角度来看，就好像多个进程同时运行一样了。本文就是对进程调度进行研究、实验的。 本文首先对Linux系统进行了简要的介绍, 然后介绍了进程管理的相关理论知识。其次，又介绍最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）、先来先服务算法的相关知识，并对进程调度进行最高优先数优先的调度算法和先来先服务算法模拟实验，并对比分析两种算法的优缺点，从而加深对进程概念和进程调度过程/算法的理解 设计目的：在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个。也就是说能运行的进程数大于处理机个数。为了使系统中的进程能有条不紊地工作，必须选用某种调度策略，选择某一进程占用处理机。使得系统中的进程能够有条不紊的运行，同时提高处理机的利用率以及系统的性能。所以设计模拟进程调度算法（最高优先数优先的调度算法、先来先服务算法），以巩固和加深处理进程的概念，并且分析这两种算法的优缺点。关键词：linux 进程调度调度算法 进程调度研究现状分析 （中南大学信息学院） 【摘要】：调度算法是指根据系统的资源分配策略所规定的资源分配算法．本文详细地讨论了先来先服务调度算法、短作业（进程）优先调度算法、时间片轮转调度算法、优先级调度算法、最短剩余时间优先、高响应比优先调度算法、多级反馈队列调度算法、最晚时间限调度等八种常用作业调度算法的基本思想，并就其性能的进行了比较分析。 【关键字】：调度策略；FCFS；SPJ；RR；优先级 【Abstract】：Scheduling algorithm is defined as the resource allocation strategy for the allocation of resources required by algorithm. This article discussed in detail first-come first-serve scheduling algorithm, the short operations (the process) priority scheduling algorithm, time scheduling algorithm rotary tablet, priority scheduling algorithm, the shortest time remaining priority, high priority response ratio scheduling algorithm, multi-level feedback queue scheduling algorithm the latest scheduling time limit of eight common operations, such as the basic idea of scheduling algorithm and its performance on a comparative analysis. 【Key Words】：Scheduling strategy; FCFS; SPJ; RR; Priority 【正文】: 1、引言 随着现代操作系统的日趋成熟，用户对计算机的需求越来越多，处理机在同一时刻能处理的资源是有限的，从而导致各种任务随时随地争夺使用处理机，因此对程序的并发能力提出了更高的要求。 引进并发技术后，为了更好地说明并发现象（尤其是动态过程），引入了进程的概念。进程是一个具有一定独立功能的可并发执行的程序关于某个数据集合的一次运行活动。一个程序的启动执行，便是一个进程的建立；一个程序执行结束（正常或非正常结束），便是一个进程的撤销。由于同时处于就绪态（争夺使用CPU资源）的进程经常比较多，因此需要CPU调度算法来决定由哪个进程获得CPU使用权进入运行态，即进程调度算法（策略）。计算机操作系统进程调度实验研究报告
随机进程调度算法
进程调度算法实验报告
进程调度程序设计
进程调度算法实验报告
进程调度程序设计报告(源代码)资料
进程调度函数schedule()分析
进程调度算法实验报告
操作系统实验-进程调度程序设计
Linu进程调度策略与研究
进程模拟调度算法课程设计
操作系统原理-进程调度实验报告
管理学的研究现状及其发展趋势分析
进程调度算法1
2011180021-Linux操作系统-课程设计报告-基于Linux的进程调度模拟程序
进程调度研究现状分析