进程调度算法模拟演示
进程调度算法模拟演示
一、设计目的
进程管理是操作系统中的重要功能，用来创建进程、撤消进程、实现进程状态转换，它提供了在可运行的进程之间复用CPU的方法。在进程管理中，进程调度是核心，因为在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态，当就绪进程个数大于处理器数目时，就必须依照某种策略决定哪些进程优先占用处理器。
本实验模拟在单处理器情况下的进程调度，目的是加深对进程调度工作的理解，掌握不同调度算法的优缺点。
二、设计内容
设计一个按先来先服务，算法时间片轮转法，优先数调度算法实现处理器调度的程序。
三、开发环境
windows环境，VC6.0平台。
四、分析设计
1、实验原理
进程是程序在处理机上的执行过程。进程存在的标识是进程控制块（PCB），所谓系统创建一个进程，就是由系统为某个程序设置一个PCB，用于对该进程进行控制和管理。进程任务完成，由系统收回其PCB，该进程便消亡。每个进程可有三个状态：运行状态、就绪状态和完成状态。因此设计三个链队列，finish为完成队列的头指针，ready为就绪队列的头指针，tail为循环轮转法中的就绪队列的尾指
针。因为每一时刻，CPU只能运行一个进程，所以运行队列只有一个run指针指向当前运行的进程。考虑到处理的方便，将它们设为全局变量。
（1）优先调度算法
优先调度算法要为每一个进程设一个优先数，它总是把处理机给就绪队列中具有最高优先权的进程。常用的算法有静态优先权法和动态优先权法。本程序采用了动态优先权法，使进程的优先权随时间而改变。初始的进程优先数取决于进程运行所需的时间，时间大，则优先数低，所以采取了将进程优先数定位一个较大的数（50）减去进程运行所需要的时间，随着进程的运行优先数进行调整，每次运行时都是从就绪队列中选取优先数最大的进程运行，所以将就绪队列按照优先数的大小从高到低排序，这样，每次取对头进程即可。
（2）时间片轮转算法
时间片轮转算法是将所有进程按先来先服务的规则排成一个队列，把CPU分配给就绪队列的对首进程，并规定它执行一定时间，称此时间间隔为时间片。当时间片完时，剥夺该进程的执行，将它送至就绪队列的末尾，并把处理机分配给就绪队列的新队首进程，同样也让它执行一个时间片。这样，就绪队列中的所有进程均可获得一个时间片的处理机运行，知道所有进程全部执行完毕。
（3）先来先服务算法
先来先服务调度算法是按照进程进入就绪队列的先后顺序调度并分配处理机执行。先来先服务算法是一种不可抢占的算法，先进入
就绪队列的进程，先被处理机运行，一旦一个进程占有了处理机，它就一直运行下去，直到该进程完成工作或者因为等待某种事件而不能继续运行时才释放处理机。
2、程序结构
（1）进程控制块结构
typedef struct node
{
char name[10]; /*进程标识符*/
int prio; /*进程优先数*/
int round; /*进程时间轮转时间片*/
int cputime; /*进程占用CPU时间*/
int needtime; /*进程到完成还要的时间*/
int arrivetime; /*进程到达时间*/
int starttime; /*进程开始时间*/
int finishtime; /*进程完成时间*/
int servicetime; /*进程服务时间*/
float turnaroundtime; /*进程周转时间*/
float weightedturnaroundtime; /*进程带权周转时间*/
int count; /*计数器*/
char state; /*进程的状态*/
struct node *next; /*链指针*/
}PCB;
2.main()主函数
首先确定选用的调度算法，用switch()选择语句来实现，然后输入进程数目，根据选用的调度算法调用相应的函数创建进程和执行调度算法。
3.create1()、create2()和create3()创建进程函数
创建进程函数的功能既创建进程控制块（PCB），并将此PCB链入就绪队列中。
create1()是按照优先数调度算法创建进程，用户输入进程标识符na以及进程所需的时间time,因为是用链表，所以申请空间存放进程PCB信息，进程的初始状态设定为“W”（就绪状态），优先数为50-time （也可以是其他数），目的是所需时间短的优先数高。将每个进程的PCB调用函数insert1()按照优先数大小从高到低排到就绪队列中。
create2()是按照时间片轮转调度算法创建进程，用户输入进程标识符na以及进程所需的时间time，申请空间存放进程PCB的信息，进程的初始状态设为“W”（就绪状态），时间片数设为2，统计运行所用的时间片的计数器变量count初值为0，调用函数insret2()将每个进程PCB按照输入的先后顺序插入到就绪队列的末尾。就绪队列创建好后，将队列中的第一个PCB变为运行态“R”，将run指针指向它，ready指针后移，作为就绪队列的新头指针，然后调用算法，注意每一时刻只能有一个进程处于运行态。
create3()是按照先来先服务调度算法创建进程，用户输入进程的名字、到达时间arrivetime以及进程所需的时间servicetime，申请空
间存放进程PCB的信息，进程的初始状态设为“W”（就绪状态），调用函数insret3()将每个进程PCB按照输入的先后顺序插入到就绪队列的末尾。就绪队列创建好后，将队列中的第一个PCB变为运行态“R”，将run指针指向它，ready指针后移，作为就绪队列的新头指针，然后调用算法。
4.insert1()、insert2()和insert3()插入函数
这三个函数完成就绪队列的建立和管理。
insert1()的功能是将还未完成且优先数小于其他进程的PCB按进程优先数的顺序插入到就绪队列中，这个函数主要考虑插入位置。insert2()是轮转法用的函数，功能是将执行了一个时间片且还未完成的进程的PCB插入到就绪队列的对尾，这个算法比较简单，只需改变尾指针。
insert3()函数功能是按进程进入系统的先后顺序插入到就绪队列中，先进入系统的进程先被处理机调度。
5.priority()优先调度算法
在prioyity()中，进程每执行一次，优先数减3（自定），CPU时间数加1，进程还需要的时间数减1,。如果进程所需的时间为0，说明进程运行完毕，将其状态变为完成状态“F”，将此PCB插入到完成队列中，程序设计插入在完成队列的头。此时就绪队列不空的话。调用函数firstin()，将就绪队列中的第一个PCB变为运行状态。如果进程没有完成，则将其优先数和就绪队列中第一个PCB的优先数作比较，如果小，则将其变为就绪态，调用insert1()函数按照优先数插
入到就绪队列中，调用firstin()函数将就绪队列中的第一个PCB变为运行态投入运行，即将优先级别高的进程投入运行，保证优先数高的优先调用，重复上述过程，直到就绪队列为空，所有进程成为完成态为止。
6.round()时间片轮转调度算法
在round()中，采用固定的时间片，时间片数设为2，进程每执行一次，计数器加1，CPU时间片数加1，进程还需等待的时间片减1，如果进程所需要的时间为0，说明进程运行完毕，将其状态变为完成状态“F”，将此PCB插入到完成队列中，程序设计插入在完成队列的头。如果进程没有完成，而计数器等于固定时间片2，即到时间了，则将其变为就绪态插入到就绪队列的队尾，同时计数器清零，等待再次轮转到时调用。此时如果就绪队列不空的话，调用函数firstin()，将就绪队列的第一个PCB变为运行态，重复上述过程，知道就绪队列为空，所有进程成为完成态为止。
7、FIFO先来先服务算法
调用insert3()函数将就绪队列按照到达系统时间的大小进行排列，先到达系统的进程排在队列的前面，等待服务。此外，需要计算进程的周转时间turnaroundtime和带权周转时间weightedturnaroundtime，周转时间是指进程进入后备状态到该进程执行完毕这一时间间隔，带权周转时间是指该进程的周转时间与其服务（运行）时间的比值。8、firstin()CPU分配
将就绪队列中的第一个进程投入运行
9、prt()输出函数
输出没执行一次后的所有PCB信息，查看进程状态和优先数或时间片的变化，顺序依次是运行进程、就绪进程、完成进程。prt1()是显示标题函数，prt2()是输出进程控制块数据。
三、程序框图
四、实验结果
1、优先级调度算法演示
2、时间片轮转算法模拟
3、先来先服务算法模拟
五、心得与体会
在本次实习中，我对进程调度的理解再次加深了，这是在平常学习的基础上，与程序相结合的过程，让我再次感受到编程给我们带来的无穷魅力，只要自己有兴趣，其实编程也是一件有趣的事，为了达到一定的要求，我们必须多次尝试用不同的方法去实现它，比如，进程调度有先来先服务算法，对于这个算法，可以用数组实现，也可以用链表实现，但是到底哪个更好哪个更灵活呢，相信学过C语言的人都知道肯定是用链表实现最好了。总之，这次实习我学到了许多，也对自己所学的是知识有了更深的理解。
六、源程序
#include
#include
#include
#include
typedef struct node
{
char name[10]; /*进程标识符*/
int prio; /*进程优先数*/
int round; /*进程时间轮转时间片*/
int cputime; /*进程占用CPU时间*/
int needtime; /*进程到完成还要的时间*/
int arrivetime; /*进程到达时间*/
int starttime; /*进程开始时间*/
int finishtime; /*进程完成时间*/
int servicetime; /*进程服务时间*/
float turnaroundtime; /*进程周转时间*/
float weightedturnaroundtime; /*进程带权周转时间*/
int count; /*计数器*/
char state; /*进程的状态*/
struct node *next; /*链指针*/
}PCB;
PCB *finish,*ready,*tail,*run; /*队列指针*/
int N; /*进程数*/
/*将就绪队列中的第一个进程投入运行*/
void firstin()
{
run=ready; /*就绪队列头指针赋值给运行头指针*/
run->state='R'; /*进程状态变为运行态*/
ready=ready->next; /*就绪对列头指针后移到下一进程*/
}
/*****标题输出函数*****/
void prt1(char a)
{
switch(a)
{
case 1: /*优先数法*/
printf("名字进程占用CPU时间进程到完成还要的时间优先级数状态\n");break;
case 2: /*时间片算法*/
printf("名字进程占用CPU时间进程到完成还要的时间计数器时间片状态\n");break;
case 3: /*先来先服务算法*/
printf("名字到达时间开始时间服务时间完成时间周转时间带权周转时间状态\n");break;
default:break;
}
}
/*****进程PCB输出*****/
void prt2(char a,PCB *q)
{
switch(a)
{
case 1: /*优先数法的输出*/
printf("%-10s\t%-10d\t%-10d\t%-10d\t%c\n",q->name,
q->cputime,q->needtime,q->prio,q->state);break;
case 2:/*轮转法的输出*/
printf("%-10s%-20d%-15d%-10d%-10d%-c\n",q->name,
q->cputime,q->needtime,q->count,q->round,q->state);break;
case 3:/*先来先服务算法输出*/
printf("%s%10d%10d%10d%10d%10.1f%10.2f\t\t%c\n",q->name,q->arrivetime,q->starttim e,q->servicetime,q->finishtime,
q->turnaroundtime,q->weightedturnaroundtime,q->state);break;
default:break;
}
}
/*****输出函数*****/
void prt(char algo)
{
PCB *p;
prt1(algo); /*输出标题*/
if(run!=NULL) /*如果运行指针不空*/
prt2(algo,run); /*输出当前正在运行的PCB*/
p=ready; /*输出就绪队列PCB*/
while(p!=NULL)
{
prt2(algo,p);
p=p->next;
}
p=finish; /*输出完成队列的PCB*/
while(p!=NULL)
{
prt2(algo,p);
p=p->next;
}
getch(); /*压任意键继续*/
}
/*****优先数的插入算法*****/
void insert1(PCB *q)
{
PCB *p1,*s,*r;
int b;
s=q; /*待插入的PCB指针*/
p1=ready; /*就绪队列头指针*/
r=p1; /*r做p1的前驱指针*/
b=1;
while((p1!=NULL)&&b) /*根据优先数确定插入位置*/ if(p1->prio>=s->prio)
{
r=p1;
p1=p1->next;
}
else
b=0;
if(r!=p1) /*如果条件成立说明插入在r与p1之间*/ {
r->next=s;
s->next=p1;
}
else
{
s->next=p1; /*否则插入在就绪队列的头*/
ready=s;
}
}
/*****轮转法插入函数*****/
void insert2(PCB *p2)
{
tail->next=p2; /*将新的PCB插入在当前就绪队列的尾*/ tail=p2;
p2->next=NULL;
}
/*****先来先服务插入函数*****/
void insert3(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->arrivetime
{
r=p1;
p1=p1->next;
}
else
b=0;
if(r!=p1)
{
r->next=s;
s->next=p1;
}
else
{
s->next=p1;
ready=s;
}
}
/*****优先数创建初始PCB信息*****/
void create1(char alg)
{
PCB *p;
int i,time;
char na[10];
ready=NULL; /*就绪队列头指针*/
finish=NULL; /*完成队列头指针*/
run=NULL; /*运行队列头指针*/
printf("请输入进程的名字和运行所需要的时间\n"); /*输入进程标识和所需时间创建PCB*/
for(i=1;i<=N;i++)
{
p=(PCB *)malloc(sizeof(PCB));
scanf("%s",na);
scanf("%d",&time);
strcpy(p->name,na);
p->cputime=0;
p->needtime=time;
p->state='W';
p->prio=50-time;
if(ready!=NULL) /*就绪队列不空则调用插入函数插入*/
insert1(p);
else
{
p->next=ready; /*创建就绪队列的第一个PCB*/
ready=p;
}
}
void clrscr(void);
printf(" 优先级调度算法模拟输出结果：\n");
printf("*******************************************************************\n
");
prt(alg); /*输出进程PCB信息*/
run=ready; /*将就绪队列的第一个进程投入运行*/
ready=ready->next;
run->state='R';
}
/*****轮转法创建进程PCB*****/
void create2(char alg)
{
PCB *p;
int i,time;
char na[10];
ready=NULL;
finish=NULL;
run=NULL;
printf("请输入进程的名字和运行所需要的时间\n");
for(i=1;i<=N;i++)
{
p=(PCB *)malloc(sizeof(PCB));
scanf("%s",na);
scanf("%d",&time);
strcpy(p->name,na);
p->cputime=0;
p->needtime=time;
p->count=0; /*计数器*/
p->state='W';
p->round=2; /*时间片*/
if(ready!=NULL)
insert2(p);
else
{
p->next=ready;
ready=p;
tail=p;
}
}
void clrscr(void);
printf(" 时间片轮转法模拟输出结果：\n");
printf("********************************************************************\ n");
prt(alg); /*输出进程PCB信息*/
run=ready; /*将就绪队列的第一个进程投入运行*/
ready=ready->next;
run->state='R';
}
/*****先来先服务算法创建PCB*****/
void create3(char alg)
{
PCB *p;
int i;
ready=NULL;
run=NULL;
finish=NULL;
printf("请输入进程的名字、到达时间和运行所需要的时间\n");
for(i=0;i { p=(PCB *)malloc(sizeof(PCB)); scanf("%s",p->name); scanf("%d",&p->arrivetime); scanf("%d",&p->servicetime); p->starttime=0; p->finishtime=0; p->turnaroundtime=0; p->weightedturnaroundtime=0; p->state='W'; if(ready!=NULL) insert3(p); else { p->next=ready; ready=p; } } void clrscr(void); printf(" 先来先服务算法模拟输出结果：\n"); printf("********************************************************************* ******\n"); prt(alg); run=ready; /*将就绪队列的第一个进程投入运行*/ ready=ready->next; run->state='R'; } /*****优先数调度算法*****/ void priority(char alg) { while(run!=NULL) /*当运行队列不空时，有进程正在运行*/ { run->cputime=run->cputime+1; run->needtime=run->needtime-1; run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/ if(run->needtime==0) /*如所需时间为0将其插入完成队列*/ { run->next=finish; finish=run; run->state='F'; /*置状态为完成态*/ run=NULL; /*运行队列头指针为空*/ if(ready!=NULL) /*如果就绪队列不空*/ firstin(); /*将就绪对列的第一个进程投入运行*/ } else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/ if((ready!=NULL)&&(run->prio { run->state='W'; insert1(run); firstin(); /*将就绪队列的第一个进程投入运行*/ } prt(alg); /*输出进程PCB信息*/ } } /*****时间片轮转法*****/ void roundrun(char alg) { while(run!=NULL) { run->cputime=run->cputime+1; run->needtime=run->needtime-1; run->count=run->count+1; if(run->needtime==0)/*运行完将其变为完成态，插入完成队列*/ { run->next=finish; finish=run; run->state='F'; run=NULL; if(ready!=NULL) firstin(); /*就绪对列不空，将第一个进程投入运行*/ } else if(run->count==run->round) /*如果时间片到*/ { run->count=0; /*计数器置0*/ if(ready!=NULL) /*如就绪队列不空*/ { run->state='W'; /*将进程插入到就绪队列中等待轮转*/ insert2(run); firstin(); /*将就绪对列的第一个进程投入运行*/ } } prt(alg); /*输出进程信息*/ } } /*****先来先服务调度算法*****/ void FIFO(char alg) { int time; while(run!=NULL) { time=run->arrivetime>time?run->arrivetime:time; run->starttime=time; time=time+run->servicetime; run->finishtime=time; run->turnaroundtime=run->finishtime-run->arrivetime; run->weightedturnaroundtime=run->turnaroundtime/run->servicetime; run->next=finish; finish=run; run->state='F'; run=NULL; if(ready!=NULL) { run=ready; run->state='R'; ready=ready->next; } prt(alg); } } /*****主函数*****/ int main() { char algo; /*算法标记*/ void clrscr(void); char mainmenu; do{ system("cls");/*清屏*/ printf ("\n温馨提示：为保证您的操作得到预期效果，请规范输入您的信息^_^\n"); printf("\n\n"); printf("\t\t +━━━━━━━━━━━━━━━━━━━━━━━━+\n"); printf("\t\t | | 欢迎进入进程调度算法模拟演示系统| | \n"); printf("\t\t | ┗━━━━━━━━━━━━━━━━┛| \n"); printf("\t\t | | \n"); printf("\t\t | ●[1]优先级算法演示| \n"); printf("\t\t | | \n"); printf("\t\t | ●[2]时间片轮转算法演示| \n"); printf("\t\t | | \n"); printf("\t\t | ●[3]先来先服务算法演示| \n"); printf("\t\t | | \n"); printf("\t\t | ●[4]退出系统| \n"); printf("\t\t | | \n"); printf("\t\t +━━━━━━━━━━━━━━━━━━━━━━━━+\n"); printf ("请输入您的选择：\n"); scanf("%d",&algo); /*输入字符确定算法*/ switch(algo) { case 1: printf("您选择的是优先级算法模拟进程调度\n\n"); printf("请输入进程数目\n"); scanf("%d",&N); /*输入进程数*/ create1(algo); /*优先数法*/ priority(algo); break; case 2: printf("您选择的是时间片轮转算法模拟进程调度\n\n"); printf("请输入进程数目\n"); scanf("%d",&N); /*输入进程数*/ create2(algo); /*轮转法*/ roundrun(algo); break; case 3: printf("您选择的是先来先服务算法模拟进程调度\n\n"); printf("请输入进程数目\n"); scanf("%d",&N); /*输入进程数*/ create3(algo); FIFO(algo); break; case 4: printf(" 欢迎您再次使用进程调度算法模拟系统! \n"); exit(4); break; default: printf("输入有误\n"); break; } printf("\n是否继续操作(y/n) ?"); fflush(stdin); mainmenu=getchar(); } while(mainmenu=='y'||mainmenu=='Y'); return 0; } 华北科技学院计算机系综合性实验 实验报告 课程名称操作系统C 实验学期2012至2013学年第2学期学生所在系部计算机系 年级专业班级 学生姓名学号 任课教师杜杏菁 实验成绩 计算机系制 《操作系统C》课程综合性实验报告 开课实验室：基础六机房2013年6月3日 实验题目进程调度算法模拟 一、实验目的 通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。 二、设备与环境 1.硬件设备：PC机一台 2.软件环境：安装Windows操作系统或者Linux操作系统，并安装相关的程序开发环境，如C \C++\Java等编程语言环境。 三、实验内容 （1）用C语言（或其它语言，如Java）实现对N个进程采用某种进程调度算法（如动态优先权调度）的调度。 （2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段： ?进程标识数ID。 ?进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。 ?进程已占用CPU时间CPUTIME。 ?进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。 ?进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进 入阻塞状态。 ?进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将 转换成就绪状态。 ?进程状态STATE。 ?队列指针NEXT，用来将PCB排成队列。 （3）优先数改变的原则： ?进程在就绪队列中呆一个时间片，优先数增加1。 ?进程每运行一个时间片，优先数减3。 （4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。 《操作系统原理》实验报告 实验名称：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)。 } 设计性实验报告 一、实验目的 1.在Linux下用C语言编程模拟优先级进程调度算法和时间片轮转进程调度算法。 2.为了清楚地观察每个进程的调度过程，每次调度程序应将各个进程的情况显示出来。 二、总体设计（设计原理、设计方案及流程等） 1、优先级进程调度算法 采用动态优先级进程调度算法，其基本思想是每次调度总是把处理机分配给优先级最高的进程，同时在运行过程中进程的优先级随着执行或等待的时间而降低或增加。 在该实验中每个进程用一个进程控制块（ PCB）表示。进程控制块包含如下信息：进程号，进程名、优先数、需要运行时间、已用CPU时间、进程状态。进程号，名字，优先数，运行的时间，事先人为地指定。每个进程的状态可以是就绪，执行，阻塞或完成4种状态之一。 就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。就绪队列中的进程在等待一个时间片后，优先级增1。如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时将进程的优先级减1，然后把它插入就绪队列等待CPU。 2、时间片轮转调度算法 采用简单时间片轮转调度算法，其基本思想是：所有就绪进程按 FCFS排成一个队列，总是把处理机分配给队首的进程，各进程占用CPU的时间片相同。如果运行进程用完它的时间片后还未完成，就把它送回到就绪队列的末尾，把处理机重新分配给队首的进程。直至所有的进程运行完毕。 三、实验步骤（包括主要步骤、代码分析等） 1.打开linux虚拟机，用vim编辑器打开代码进行修改和调整。用gcc编译器进行编译编译运行首先运行优先级算法，如图所示： 福建农林大学计算机与信息学院 课程设计报告 课程名称：操作系统 实习题目：进程调度算法模拟 姓名： 系：计算机科学与技术系 专业：计算机科学与技术 年级：2012 学号： 指导教师： 职称：副教授 年月日 福建农林大学计算机与信息学院计算机类 课程设计结果评定 目录 1.本选题课程设计的目的 (4) 2.本选题课程设计的要求 (4) 3.本选题课程设计报告内容 (4) 3．1前言 (4) 3．2进程调度算法模拟的环境 (4) 3．3系统技术分析 (4) 3．4系统流程图及各模块 (5) 3．5程序调试情况 (8) 4．总结 (11) 参考文献 (11) 程序代码 (12) 1.设计目的 课程设计将课本上的理论知识和实际有机的结合起来，锻炼学生的分析系统，解决实际问题的能力。提高学生分析系统、实践编程的能力。 2.设计要求 利用学到的操作系统和编程知识，完成具有一定难度的系统分析研究或系统设计题目。其中：专题系统理论研究应包括研究目的、目标，论点和论据以及证明推导等；分析、设计系统应包括编写、调试程序以及最后写出设计报告或系统说明文档文件，系统说明文档包括系统界面、变量说明、系统功能说明、编程算法或思路、流程图和完整程序。具体要求如下： 1、对系统进行功能模块分析、控制模块分析正确； 2、系统设计要实用； 3、编程简练，可用，功能全面； 4、说明书、流程图要清楚。 3.设计方案 3.1前言 本程序包括三种算法，用C或C++语言实现，执行时在主界面选择算法（可用函数实现），进入子页面后输入进程数，（运行时间，优先数由随机函数产生），执行，显示结果。 3.2本选题设计的环境 WindowsXP下的Microsoft Visual C++ 6.0 3.3系统技术分析 （1）编程实现对N个进程采用某种进程调度算法（如动态优先权调度算法、先来先服务算法、短进程优先算法、时间片轮转调度算法）调度执行的模拟。（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：进程标识数ID。 进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。 实验一模拟实现进程调度算法(4学时) ①、实验目的 a、进程调度是处理机管理的核心内容。观察、体会操作系统的进程调度方法，并通过一个简单的进程调度模拟程序的实现，加深对进程控制块、进程队列、进程调度算法，进程切换的理解，并体会和了解各种调度算法的具体实施办法。 b、提高实际动手编程能力，为日后从事软件开发工作打下坚实基础。 ②、实验内容 a、设计进程控制块PCB表结构，模拟实现进程调度算法：FIFO，静态优先级调度，时间片轮转调度，短进程优先调度算法，多级反馈队列调度。（实现静态优先级调度算法、短进程优先调度算法）。 b、编写一个进程调度程序模拟程序。模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。 c、由用户输入（可通过文件输入）进程名、进程状态、进程运行时间和进程优先级等数据。 ③、实验要求 a、使用模块化设计思想来设计。 b、给出主函数和各个算法函数的流程图。 c、学生可按照自身条件，随意选择采用的算法，（例如：采用冒泡法编写程序，实现短进程优先调度的算法）。 d、进程调度程序模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。 ④、运行结果 a、给出进程的调度模拟操作排序结果。 ⑤、提示 a、每个进程可有三个状态，并假设初始状态为就绪状态。 b、为了便于处理，程序中的进程运行时间以纳秒为单位计算。 C、各进程的优先级或轮转时间数以及进程需运行的纳秒数的初始值均由用户给定。 d、在优先级算法中，采用静态优先级。在时间片轮转算法中，采用可变时间片，由用户给定。 e、对于遇到优先级一致的情况，采用FIFO策略解决。 f、输入：进程流文件（文本文件），其中存储的是一系列要执行的进程，每个进程包括四个数据项：进程名进程状态(1就绪2等待3运行) 所需时间优先级(0级最高)。 g、输出：进程执行流等待时间平均等待时间。 ⑥、分析与讨论 a、各种进程调度算法的异同？ b、如何理解“算法+数据结构=程序设计”？ c、如何理解“数据结构始终是为实现功能服务的”？ ⑦、参考代码 参看：附录A1 考核方法： 1、实验报告占50%，程序设计30%，出勤占20%； 3、每次实验100分，2次实验的平均分为最终实验成绩。 注：无出勤只交实验报告者，以实验报告成绩×50%为最后成绩。 打游戏者发现一次本次实验扣10分。 早退者本次实验扣10分。 点名时未到者，后来补签到按照迟到时间长短扣分，点名后即来扣5分，1节课过后才来扣10分。 实验二单处理器系统的进程调度 （附实验报告） 1．实验目的 加深对进程概念的理解，明确进程和程序的区别； 深入了解系统如何组织进程、创建进程； 进一步认识如何实现处理器调度。 2．实验预备知识 进程的概念； 进程的组织方式； 进程的创建； 进程的调度。 3．实验内容 编写程序完成单处理机系统中的进程调度，要求采用时间片轮转调度算法。实验具体包括：首先确定进程控制块的内容，进程控制块的组成方式；然后完成进程创建原语和进程调度原语；最后编写主函数对所作工作进程测试。 4．提示与讲解 这个实验主要要考虑三个问题：如何组织进程、如何创建进程和如何实现处理器调度。 考虑如何组织进程，首先就要设定进程控制块的内容。进程控制块PCB 记录各个进程执行时的情况。不同的操作系统，进程控制块记录的信息内容不一样。操作系统功能越强，软件也越庞大，进程控制块记录的内容也就越多。这里的实验只使用了必不可少的信息。一般操作系统中，无论进程控制块中信息量多少，信息都可以大致分为以下四类： ①标识信息 每个进程都要有一个惟一的标识符，用来标识进程的存在和区别于其他进程。这个标识符是必不可少的，可以用符号或编号实现，它必须是操作系统分配的。在后面给出的参考程序中，采用编号方式，也就是为每个进程依次分配一个不相同的正整数。 ②说明信息 用于记录进程的基本情况，例如进程的状态、等待原因、进程程序存放位置、进程数据存放位置等等。实验中，因为进程没有数据和程序，仅使用进程控制块模拟进程，所以这部分内容仅包括进程状态。 ③现场信息 现场信息记录各个寄存器的内容。当进程由于某种原因让出处理器时，需要将现场信息记录在进程控制块中，当进行进程调度时，从选中进程的进程控制块中读取现场信息进行现场恢复。现场信息就是处理器的相关寄存器内容，包括通用寄存器、程序计数器和程序状态字寄存器等。在实验中，可选取几个寄存器作为代表。用大写的全局变量AX、BX、CX、DX模拟通用寄存器、大写的全局变量PC模拟程序计数器、大写的全局变量PSW模拟程序状态字寄存器。 ④管理信息 管理信息记录进程管理和调度的信息。例如进程优先数、进程队列指针等。实验中，仅包括队列指针。 因此可将进程控制块结构定义如下： struct pcb {int name; int status; int ax, bx, cx,dx; 操作系统实验报告（二） 实验题目：进程调度算法 实验环境：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<<"请输入进程个数:"< 操作系统课程设计报告题目：进程调度算法的模拟实现_ 专业计算机科学与技术 学生姓名 班级 学号 指导教师 发放日期2015.1.30 信息工程学院 目录 1 概述 (1) 2 设计原理 (1) 2.1先来先服务算法 (1) 3 详细设计与编码 (2) 3.1 模块设计 (2) 3.2 系统流程图 (2) 3.3 系统详细设计 (2) 4 结果与分析 (6) 4.1 测试方案 (6) 4.2 测试结果 (6) 4.3 测试结果分析 (9) 5 设计小结 (10) 6 参考文献 (10) 附录程序代码 (12) 进程调度算法的模拟实现 进程调度算法的模拟实现 1 概述 选择一个调度算法，实现处理机调度，进程调度算法包括：先来先服务算法，短进程优先算法，时间片轮转算法，动态优先级算法。可选择进程数量，本程序包括四种算法，用C或C++语言实现，执行时在主界面选择算法（可用函数实现），进入子页面后输入进程数，（运行时间，优先数由随机函数产生），执行，显示结果。 2 设计原理 2.1先来先服务(FCFS)算法 每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源创建进程，然后放入就绪队列 2.2 时间片轮转法(RR)算法 系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。时间片的大小从几ms到几百ms。当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。 2.3短作业优先(SJF)算法 短作业优先调度算法是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。 2.4最高优先权优先(HRRN)算法 优先权调度算法是为了照顾紧迫型作业，使之在进入系统后便获得优先处理，引入最高优先权优先调度算法。动态优先权是指在创建进程时所赋予的优先权，是可以随进程的推进或随其等待时间的增加而改变的，以便获得更好的调度性能。 使用动态优先权的进程调度算法的模拟实验 1.实验目的 通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解。 2.实验内容 （1）用C语言实现对N个进程采用动态优先权优先算法的进程调度； （2）每个用来标识进程的进程控制块PCB用结构来描述，包括以下字段： ●进程标识数； ●进程优先数priority，并规定优先数越大的进程，其优先权越高； ●进程已占用的CPU时间cputime； ●进程还需占用的CPU时间alltime，当进程运行完毕时，alltime变为0； ●进程的阻塞时间startblock，表示当进程再运行startblock个时间片后，进程将进入阻塞 状态； ●进程被阻塞的时间blicktime，表示已阻塞的进程再等待blocktime个时间片后，将转换 为就绪态； ●进程状态state； ●队列指针next，用来将PCB排成队列。 （3）优先数改变的原则： ●进程在就绪队列中呆一个时间片，优先数增加1. ●进程每运行一个时间片，优先数减3。 （4）假设在调度前，系统中有5个进程，它们得初始状态如下： ID 0 1 2 3 4 PRIORITY 9 38 30 29 0 CPUTIME 0 0 0 0 0 ALLTIME 3 3 6 3 4 STARTBLOCK 2 -1 -1 -1 -1 BLOCKTIME 3 0 0 0 0 STATE READY READY READY READY READY （5）为了清楚地观察诸进程的调度过程，程序应将每个时间片内的进程的情况显示出来，参照的具体格式如下： RUNNING PROG：i READY_QUEUE：->id1->id2 BLOCK_QUEUE：->id3->id4 ====================================================================== ID 0 1 2 3 4 PRIORITY P0 P1 P2 P3 P4 CPUTIME C0 C1 C3 C4 C5 ALLTIME A0 A1 A2 A3 A4 STARTBLOCK T0 T1 T2 T3 T4 BLOCKTIME B0 B1 B2 B3 B4 STATE S0 S1 S2 S3 S4 一．课程概述 1.1.设计构想 程序能够完成以下操作：创建进程：先输入进程的数目，再一次输入每个进程的进程名、运行总时间和优先级，先到达的先输入；进程调度：进程创建完成后就选择进程调度算法，并单步执行，每次执行的结果都从屏幕上输出来。 1.2.需求分析 在多道程序环境下，主存中有着多个进程，其数目往往多于处理机数目，要使这多个进程能够并发地执行，这就要求系统能按某种算法，动态地把处理机分配给就绪队列中的一个进程，使之执行。分配处理机的任务是由处理机调度程序完成的。由于处理机是最重要的计算机资源，提高处理机的利用率及改善系统必（吞吐量、响应时间），在很大程度上取决于处理机调度性能的好坏，因而，处理机调度便成为操作系统设计的中心问题之一。本次实验在VC++6.0环境下实现先来先服务调度算法，短作业优先调度算法，高优先权调度算法，时间片轮转调度算法和多级反馈队列调度算法。 1.3.理论依据 为了描述和管制进程的运行，系统为每个进程定义了一个数据结构——进程控制块PCB(Process Control Block),PCB中记录了操作系统所需的、用于描述进程的当前情况以及控制进程运行的全部信息，系统总是通过PCB对进程进行控制，亦即，系统是根据进程的PCB 而不是任何别的什么而感知进程的存在的，PCB是进程存在的惟一标志。本次课程设计用结构体Process代替PCB的功能。 1.4.课程任务 一、用C语言（或C++）编程实现操作模拟操作系统进程调度子系统的基本功能；运用多 种算法实现对进程的模拟调度。 二、通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转、短作业优先、多 级反馈队列调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。 三、实现用户界面的开发 实验一、进程调度实验报告 广东技术师范学院实验报告 学院：计算机科学学 院 专业： 计算机科学与 技术（师范） 班级：成绩： 姓名：学号：组别：组员： 实验地点：实验日期：指导教师签名： 实验名称：实验一、进程调度实验 一、实验目的 用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解 二、实验类别 综合性实验。综合高级语言编程、进程调度模型、进程调度算法及数据结构等多方面的知识 三、实验内容和步骤 1．编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对五个进程进行调度。 “最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。 静态优先数是在创建进程时确定的，并在整个进程运行期间不再改变。 动态优先数是指进程的优先数在创建进程时可以给定一个初始值，并且可以按一定原则修改优先数。例如：在进程获得一次CPU后就将其优先数减少1。或者，进程等待的时间超过某一时限时增加其优先数的值，等等 该题根据老师给的代码用Visual C++运行，结果以及分析如下： 预习情况操作情况考勤情况数据处理情况 结果分析：根据上述输入的三个进程的信息可以得到：优先级最高的是进程cc 最先调度进程cc的状态为运行态，需要执行的时间为10当前就绪队列状态为：进程aa先级比较高，处于就绪队列前面，而进程bb先级是三者中最低的，所以处于就绪队列的最后。而此时这两个进程的状态都为就绪态。 结果分析：当进程cc了一个时间片之后而它已占用CPU时间已达到所需要的运行时间，则将它的优先级减1之后，再将三个进程按优先级的大小排列，从中选择优先级大的进程进入运行状态，则该次进入运行态的是进程aa 按照这种方式一直运行下去： 直到: 进程调度模拟实验 pr a[MAX]; int n;//进程数 int t;//时间片大小 void input() { int i; printf("请输入进程的名字优先级到达系统时间运行时间:(中间用空格隔开)\n"); for(i=0;i for(j=0;j （1）用C语言（或其它语言，如Java）实现对N个进程采用某种进程调度算法（如动态优先权调度）的调度。 （2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：?进程标识数ID。 ?进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。 ?进程已占用CPU时间CPUTIME。 ?进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。 ?进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间 片后，进程将进入阻塞状态。 ?进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME 个时间片后，将转换成就绪状态。 ?进程状态STATE。 ?队列指针NEXT，用来将PCB排成队列。 （3）优先数改变的原则： ?进程在就绪队列中呆一个时间片，优先数增加1。 ?进程每运行一个时间片，优先数减3。 （4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。 （5）分析程序运行的结果，谈一下自己的认识。 实验代码 #include "iostream.h" #include "windows.h" //#define N 3 typedef struct{ int ID; int PRIORITY; int CPUTIME; int ALLTIME; int STARTBLOCK; int BLOCKTIME; int STATE;//0-运行1-阻塞2-就绪3-结束4-未到达 int REACH; int TIME; }PROCESS; void textcolor (int color) { SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color ); } void main(){ int i,time,max,l,l1,time1,flag=0,total=0,N,server[10],sum=0; PROCESS pro[10]; textcolor(13); cout<<"注意：本程序中状态代表如下"< 进程调度模拟实验说明书 目录 前 言 ..................................................................... .......... 错误～未定义书签。2 摘 要 ..................................................................... .......... 错误～未定义书签。3 正 文 ..................................................................... .......... 错误～未定义书签。4 1. 设计思 想 ................................................................ 错误～未定义书签。4 2. 算法中用到的主要数据结构(采用类C语言定义)........................53. 相关的各程序伪代码..............................................................6 4. 调试分析...........................................................................9 5. 测试结果..........................................................................11 6( 源程序(带注释)..................................................................... (12) 总结 (16) 参考文献.....................................................................................17 致谢...........................................................................................18附件1部分源代码 (19) 1 前言 操作系统 ——项目文档报告 进程调度算法 专业： 班级： 指导教师： 姓名： 学号： 一、核心算法思想 1.先来先服务调度算法 先来先服务调度算法是一种最简单的调度算法，该算法既可以用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将他们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。FCFS算法比较有利于长作业（进程），而不利于短作业（进程）。 2.短作业（进程）优先调度算法 短作业（进程）优先调度算法SJ（P）F，是指对短作业或短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。SJ(P)F调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。该算法对长作业不利，完全未考虑作业的紧迫程度。 3.高响应比优先调度算法 在批处理系统中，短作业优先算法是一种比较好的算法，其主要不足之处是长作业的运行得不到保证。如果我们能为每个作业引人动态优先权，并使作业的优先级随着等待时间的增加而以速率a提高，则长作业在等待一定的时间后，必然有机会分配到处理机。该优先权的变化规律可描述为: 优先权=（等待时间+要求服务时间）/要求服务时间 即优先权=响应时间/要求服务时间 如果作业的等待时间相同，则要求服务的时间越短，其优先权越高，因而该算法有利于短作业。 当要球服务的时间相同时，作业的优先权决定于其等待时间，等待时间越长，优先权越高，因而它实现的是先来先服务 对于长作业，作业的优先级可以随着等待时间的增加而提高，当其等待时间足够长时，其优先级便可以升到很高，从而也可获得处理机。 4.时间片轮转算法 在时间片轮转算法中，系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。当执行的时间片用完时，由一个计数器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。换言之，系统能在给定的时间内响应所有用户的请求。 二、核心算法流程图 计算机操作系统综合设计 实验四 实验名称：进程调度模拟实现 实验类型：设计型实验 实验环境： Visual C++ 6.0 指导老师：陈立伟 专业班级： 姓名： 学号: 联系电话： 实验地点：东六E座4-02 实验日期： 2014年12月7日 实验报告日期： 2014年12月 7日 成绩：__________________________ 一、实验目的 1)理解进程调度相关理论。 2)掌握FCFS进程调度方法。 二、实验平台 windows 7 Visual C++ 6.0 三、实验步骤 1、实验内容 1）设计可用于该实验的进程控制块，进程控制块至少包括进程号、到达时间和要求服务时间； 2）动态或静态创建多个（≥10）进程； 3）实现FCFS或其他调度算法； 4）可动态修改进程到达时间； 5）调度所创建的进程并显示调度结果。 2、实验步骤 1）输入给定的实验指导书中提供的代码 A、打开Visual C++ 6.0； B、新建c++文件，创建FCFS.cpp； 2）进行功能测试并得出正确结果 A、编译、运行FCFS.cpp； 输入8，即是8个进程数。 输入8个进程号，以及到达时间和所需时间。 得到执行结果： 进程执行的先后顺序； 进程开始执行的时间； 输入y:要修改输入修改项，再次得到结果； 四、实验总结 因为FCFS是先来先服务的算法，我们是依据它的进程到达的时间来规定进程的执行顺序的，所以还要对输入的进程，按照它的进程到达时间来排序，并按照这个顺序执行进程，输入的有进程号，进程到达时间，进程执行时间，所以我们定义了一个结构体，里面包含了以上三个内容，并且定义两个全局变量：int time = 0; char flag = 'y'; 来计算总的时间还有标识是否结束程序，初始化为0和标识程序不结束的标识y。因为进程号不应该相同，所以我们不应该在输入的时候还要做一个判断遍历前面已经输入的进程，若当前输入的进程号已经存在那么提示并重新输入，不存在则顺序执行。当要修改程序到达的时间，我们要修改的必须是一个存在的，所以在做修改的输入判断的时候，就是遍历所有的进程，当输入的进程号存在的时候才做出相应动作，如果不存在那么输出提示并询问是否继续修改。 课程设计报告 设计名称：模拟实现一种处理机调度算法 学生姓名： xxx 专业：计算机科学与技术 班别： xxxxxxxx 学号： xxxxxx 指导老师： xxxxx 日期： 2014 年 6 月 20 日 初始条件： 1．预备内容：阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解。 2．实践准备：掌握一种计算机高级语言的使用。 要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求） 1．模拟进程调度，能够处理以下的情形： ⑴能够选择不同的调度算法（要求中给出的调度算法）； ⑵能够输入进程的基本信息，如进程名、优先级、到达 时间和运行时间等； ⑶根据选择的调度算法显示进程调度队列； ⑷根据选择的调度算法计算平均周转时间和平均带权周 转时间。 2．设计报告内容应说明： ⑴需求分析； ⑵功能设计（数据结构及模块说明）； ⑶开发平台及源程序的主要部分； ⑷测试用例，运行结果与运行情况分析； ⑸自我评价与总结： i）你认为你完成的设计哪些地方做得比较好或比较出 色； ii）什么地方做得不太好，以后如何改正； iii）从本设计得到的收获（在编写，调试，执行过程中 的经验和教训）； iv）完成本题是否有其他方法（如果有，简要说明该方 法）； 进程调度模拟设计——先来先服务、优先级法1、背景： 当计算机系统是多道程序设计系统时，通常会有多个进程或线程同时竞争CPU。只要有两个或更多的进程处于就绪状态，这种情形就会发生。如果只有一个CPU可用，那么就必须选择下一个要运行的进程。在操作系统中，完成选择工作的这一部分称为调度程序，该程序使用的算法成为调度算法。 进程调度的核心问题是采用什么样的算法把处理机分配给进程，好的算法将提高资源利用率，减少处理机的空闲时间，避免有些作业长期得不到相应的情况发生等，从而设计出受欢迎的操作系统。较常见的几种进程调度算法有：先来先服务调度算法；短作业优先调度算法；时间片轮转调度算法；优先级调度算法；高响应比优先算法和多级反馈队列调度算法等。 2.1设计目的 无论是在批处理系统还是分时系统中，用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。另外，系统进程也同样需要使用处理机。这就要求进程调度程序按一定的策略，动态地把处理机 进程调度模拟实验 1.实验目的 通过对进程调度算法的模拟加深对进程概念和进程调度过程的理解。 2.实验内容 用C语言、Pascal语言或其他开发工具实现对N（N=5）个进程的调度模拟，要求至少采用两种不同的调度算法（如简单轮转法Round Robin和优先权高者优先算法Highest Priority First），分别进行模拟调度。 每个用来标识进程的进程控制块PCB用结构（记录）来描述，根据需要，它包括以下字段： 进程标识数ID。 进程优先数Priority，并规定优先数越大的进程，其优先权越高。采用简单轮转法时该字段无用。 进程已经占用的CPU时间CPUTIME（以时间片为单位，下同）。 进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。 进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。 进程被阻塞的时间BLOCKTIME，表示已经阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。 进程状态STATE。 队列指针NEXT，用来将PCB排成队列。 优先数改变的原则（采用简单轮转法时该字段无用）： 进程在就绪队列中等待一个时间片，优先数增加1； 进程每运行一个时间片，优先数减3。 假设在进行调度前，系统中有5个进程，它们的初始状态可以编程输入（更具有灵活性），也可以初始化为如下内容： ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE 0 9 0 3 2 3 READY 1 38 0 3 -1 0 READY 2 30 0 6 -1 0 READY 3 29 0 3 -1 0 READY 4 0 0 4 -1 0 READY 为了清楚地观察诸进程的调度过程，程序应该将每个时间片内各进程的情况显示出来并暂停，参考格式如下： 运行/Running：I 就绪队列/Ready Queue：Idi，Idj，… 阻塞队列/Block Queue：Idk，Idl，… ====================================================================== 进程号优先数已运行时间需要时间开始阻塞时间阻塞时间状态 0 P0 C0 A0 T0 B0 S0 1 P1 C1 A1 T1 B1 S1 2 P2 C2 A2 T2 B2 S2 3 P3 C3 A3 T3 B3 S3 4 P4 C4 A4 T4 B4 S4 ====================================================================== 题目操作系统课程设计 实验一：进程调度算法 1.实验目的 通过优先权法和轮转算法的模拟加深对进程概念和进程调度过程的理解，掌握进程状态之间的切换，同时掌握进程调度算法的实现方法和技巧。2.实验内容 1）用C语言或C++语言来实现对n个进程采用优先权算法以及轮转算法的进程调度。 2）每个用来标识进程的进程控制块PCB用结构来描述，包括以下字段：（1）进程标识ID，其中0为闲逛进程，用户进程标识数为1，2，3…。 （2）进程优先级Priority，闲逛进程（idle）的优先级为0，用户进程的优先级大于0，且随机产生，标识数越大，优先级越高。 （3）进程占用CPU时间CPUtime，进程每运行一次，累计值等于4. （4）进程总共需要运行时间Alltime，利用随机函数产生。 （5）进程状态，0-就绪态；1-运行态；2-阻塞态。 （6）队列指针next，用来将多个进程控制块PCB链接为队列。 3）优先数改变的原则 （1）进程在就绪队列中每呆一个时间片，优先数增加1。 （2）进程每运行一个时间片，优先数减3. 4）在调度前，系统中拥有的进程数PCB_number由键盘输入，经初始化后，所有的进程控制块PCB链接成就绪队列。 3.实验步骤 a)画出程序流程图 a)动态优先权的进程调度算法模拟流程 b)轮转法进程调度算法模拟流程 b)程序算法如下： #include "stdafx.h" #define NULL 0 #include 进程调度算法模拟实验
随机进程调度算法
操作系统：进程调度实验报告
进程调度算法模拟 (操作系统课程设计报告)
实验一 模拟实现进程调度算法
实验二--单处理器系统的进程调度
进程调度算法实验报告
进程调度算法的模拟实现
使用动态优先权的进程调度算法的模拟实验
进程模拟调度算法课程设计
实验一、进程调度实验报告
进程调度模拟实验
进程调度算法模拟程序设计C++
进程调度模拟实验说明书
操作系统模拟进程调度算法
实验四 进程调度模拟实现
模拟一种处理机调度算法
进程调度模拟实验(四种)
进程调度算法论文优先级调度~
相关文档
- 进程调度算法的模拟实现
- 进程模拟调度算法课程设计
- 进程调度算法模拟带答案版
- 进程调度算法模拟带答案版讲解
- 进程调度算法模拟带答案版.pptx
- 操作系统进程调度模拟算法附源码
- 时间片轮转算法和优先级调度算法 C语言模拟实现
- 使用动态优先权的进程调度算法的模拟
- 操作系统进程调度算法模拟实验
- 时间片轮转进程调度模拟算法的实现
- 进程调度算法模拟实验
- 操作系统---进程调度算法的模拟
- 5种进程调度算法
- 操作系统进程调度算法模拟实验报告
- 进程调度算法实验报告
- 进程调度算法模拟程序设计C++
- 进程调度算法模拟带答案版
- 进程调度算法模拟带答案版
- 进程调度算法模拟程序(C++描述)
- 进程调度算法实验报告