高(动态)优先权优先的进程调度算法模拟

合集下载

动态高优先权

动态高优先权

动态高优先权实验报告一、实验目的通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解.提高自己的动手能力主要是通过自己去思考并自己的编码更进一步及更贴切的去理解弄明白动态优先权算法的模拟加深对进程概念和进程调度过程的工作流程及其原理!二、实验要求用C语言来实现对N个进程采用动态优先权优先算法的进程调度。

三、实验内容每个用来标识进程的进程控制块PCB用结构来描述,包括以下字段:1.进程标识数ID2.进程优先数PRIORITY,并规定优先数越大的进程,其优先权越高。

3.进程已占用的CPU时间CPUTIME。

4.进程还需占用的CPU时间ALLTIME。

当进程运行完毕时,ALLTIME变为0。

5.进程的阻塞时间STARTBLOCK,表示当进程再运行STARTBLOCK个时间片后,进程将进入阻塞状态。

6.进程被阻塞的时间BLOCKTIME,表示已阻塞的进程再等待BLOCKTIME个时间片后,将转换成就绪状态。

7.进程状态STATE。

8.队列指针NEXT,用来将PCB排成队列。

四、实验结果五、实验小结其实每次实验,老师都建议大家自己开始写程序,网上的代码可以自己选择性的参考,但绝对不能纯粹性的抄袭,但由于自己的C++基础实在是不怎么好,如果自己编的话会摸不着头脑,不知从哪里开始,就还是从网上下载了一些代码,在同学们的帮助下,理解编着的思路,明白各个模块的调度,也明白了动态高优先权的具体内容。

虽然中间碰见了不少问题,但经过多次调试,还是有了比较满意的结果。

然而这些调试是需要花费时间的,课堂的时间不够,只能课下去完成。

正所谓皇天不负有心人,努力就会有收获,经过这次试验也算是有所提高吧。

动态优先权是指在创建进程时所赋予的优先权,可以随进程的推进或随其等待时间的增加而改变的,以便获得更好的调度性能.例如,我们可以规定,在就绪队列中的进程,随其等待时间的增长,其优先权以速率a 提高.若所有的进程都具有相同的优先权初值,则显然是最先进入就绪队列的进程,将因其动态优先权变得最高而优先获得处理机,此即FCFS算法.优先权的变化规律可描述为:由于等待时间与服务时间之和,就是系统对该作业的响应时间,故该优先权又相当于响应比RP此次实验让我明白了许多,不仅是知识上的,还有认识上的,我明白任何时候都是自己动手丰衣足食,学问是自己的,是无止境的,为了以后我们只能努力的补充自己···附录#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0struct pcb { /* 定义进程控制块PCB */char name[10]; /*定义进程名称*/char state; /*进程状态*/int super; /*优先数*/int ntime; /*需要运行的时间*/int rtime; /*已占用的CPU时间*/struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB; /*pcb表*/void sort() /* 建立对进程进行优先级排列函数*/{ PCB *first, *second;int insert=0;if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者, 插入队首*/{ p->link=ready;ready=p;}else /* 进程比较优先级,插入适当的位置中*/{ first=ready;second=first->link;while(second!=NULL){ if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/{ /*插入到当前进程前面*/p->link=second;first->link=p;second=NULL;insert=1;}else /* 插入进程优先数最低,则插入到队尾*/{ first=first->link;second=second->link;}}if(insert==0) first->link=p;}}void input() /* 建立进程控制块函数*/ { int i,num;system("cls"); /*清屏*/printf("\n 请输入进程号?");scanf("%d",&num);for(i=0;i<num;i++){ printf("\n 进程号No.%d:\n",i);p=getpch(PCB);printf("\n 输入进程名:");scanf("%s",p->name);printf("\n 输入进程优先数:");scanf("%d",&p->super);printf("\n 输入进程运行时间:");scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='w';p->link=NULL;sort(); /* 调用sort函数*/}}int space(){ int l=0; PCB* pr=ready;while(pr!=NULL){ l++;pr=pr->link;}return(l);}void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/{ printf("\n qname \t state \t super \t ndtime \t runtime \n");printf("|%s\t",pr->name);printf("|%c\t",pr->state);printf("|%d\t",pr->super);printf("|%d\t",pr->ntime);printf("|%d\t",pr->rtime);printf("\n");}void check() /* 建立进程查看函数,检查等待队列的进程是否进入就绪队列*/{ PCB* pr;printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/disp(p);pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){ disp(pr);pr=pr->link;}}void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/{ printf("\n 进程[%s] 已完成.\n",p->name);free(p);}void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ { (p->rtime)++;if(p->rtime==p->ntime)destroy(); /* 调用destroy函数*/else{ (p->super)--;p->state='w';sort(); /*调用sort函数*/}}void main() /*主函数*/{ int len, h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ ch=getchar();h++;printf("\n The execute number:%d \n",h); p=ready;ready=p->link;p->link=NULL;p->state='R';check();running();printf("\n 按任一键继续......");ch=getchar();}printf("\n\n 进程已经完成.\n");ch=getchar();}。

实验四 使用动态优先权的进程调度算法的模拟

实验四   使用动态优先权的进程调度算法的模拟

实验四使用动态优先权的进程调度算法的模拟专业班级:软件1302 学号:201316920224 姓名:张长胜评分:1.实验目的通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解。

2.实验内容(1)用C语言来实现对N个进程采用动态优先权优先算法的进程调度。

(2)每个用来标识进程的进程控制块PCB用结构来描述,包括以下字段:●进程标识数ID;●进程优先数PRIORITY,并规定优先数越大的进程,其优先权越高;●进程已占用的CPU时间CPUTIME;●进程还需占用的CPU时间ALLTIME。

当进程运行完毕时,ALLTIME变为0;●进程的阻塞时间STARTBLOCK,表示当进程再运行STARTBLOCK个时间片后,进程将进入阻塞状态;●进程被阻塞的时间BLOCKTIME,表示已阻塞的进程再等待BLOCKTIME个时间片后,进程将转换成就绪状态;●进程状态STATE;●队列指针NEXT,用来将PCB排成队列。

(3)优先数改变的原则:●进程在就绪队列中呆一个时间片,优先数增加1;●进程每运行一个时间片,优先数减3。

(4)假设在调度前,系统中有5个进程,它们的初始状态如下:ID 0 1 2 3 4PRIORITY 9 38 30 29 0CPUTIME 0 0 0 0 0ALLTIME 3 3 6 3 4STARTBLOCK 2 -1 -1 -1 -1BLOCKTIME 3 0 0 0 0STATE READY READY READY READY READY(5)为了清楚地观察进程的调度过程,程序应将每个时间片内的进程的情况显示出来,参照的具体格式如下:RUNNING PROG: iREADY_QUEUE:->id1->id2BLOCK_QUEUE:->id3->id4===============================================ID 0 1 2 3 4PRIORITY P0 P1 P2 P3 P4CPUTIME C0 C1 C2 C3 C4ALLTIME A0 A1 A2 A3 A4 STARTBLOCK T0 T1 T2 T3 T4BLOCKTIME B0 B1 B2 B3 B4 STATE S0 S1 S2 S3 S43.程序设计/*define the structure of process*/#include <stdio.h>#define N 10#define P procstruct process{ int id;int py; /*priority*/int ct; /*cputime*/int at; /*alltime*/int sb; /*startblock*/int bt; /*blocktime*/int st; /*state:1 ready;-1 block;0 finish*/};struct process proc[N];main(){ int i,j,n;int max_pt,priority;int timeslice=0;int ready_q[N],block_q[N];char ch;FILE *fp;char *fname="c:\\a.txt";fp=fopen(fname,"w+");for(i=0;i<=N;i++){ ready_q[i]=0; block_q[i]=0;}n=5; /* 定义进程数量为5 *//* 初始化进程数组*/P[1].id=0; P[1].py=9; P[1].ct=0; P[1].at=3; P[1].sb=2; P[1].bt=3;P[2].id=1; P[2].py=38; P[2].ct=0; P[2].at=3; P[2].sb=-1; P[2].bt=0;P[3].id=2; P[3].py=30; P[3].ct=0; P[3].at=6; P[3].sb=-1; P[3].bt=0;P[4].id=3; P[4].py=29; P[4].ct=0; P[4].at=3; P[4].sb=-1; P[4].bt=0;P[5].id=4; P[5].py=0; P[5].ct=0; P[5].at=4; P[5].sb=-1; P[5].bt=0;/* 输出初始化的进程数组内容*/fprintf(fp,"\n\n RUNNING RPOC:%d\n",-1);fprintf(fp," READY_QUEUE :");for(i=1;i<=n;i++)fprintf(fp,"->id%d",i-1);fprintf(fp,"\n");fprintf(fp," BLOCK_QUEUE :\n ");fprintf(fp,"===================================================== ===");fprintf(fp,"\n %-12s","ID");for(i=1;i<=n;i++)fprintf(fp,"%8d",i-1);fprintf(fp,"\n %-12s","PRIORITY");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].py);fprintf(fp,"\n %-12s","CPUTIME");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].ct);fprintf(fp,"\n %-12s","ALLTIME");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].at);fprintf(fp,"\n %-12s","STARTBLOCK");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].sb);fprintf(fp,"\n %-12s","BLOCKTIME");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].bt);fprintf(fp,"\n %-12s","STATE");for(i=1;i<=n;i++){ P[i].st=1;fprintf(fp,"%8s","READY");}for(i=1;i<=n;i++){ P[i].st=1;ready_q[i]=i;}ready_q[0]=n;/* ready_q[0]表示就绪队列中进程个数,block_q[0]表示阻塞队列中进程个数*//* 进行运算*/do{ timeslice++; /* 时间片加1 *//*max_pt记录优先级最高进程的pt,ready_q数组记录就绪队列的顺序priority记录优先级最高进程的ID此程序段使ready_q排序*/for(i=1,max_pt=-1;i<=ready_q[0];i++)if (P[ready_q[i]].py>max_pt){ max_pt=P[ready_q[i]].py;j=i;priority=ready_q[i];}for(i=j;i<ready_q[0];i++)ready_q[i]=ready_q[i+1];ready_q[0]--;/* 按原则操作各进程,实质是按原则改变数组各值*/P[priority].py-=3;if (P[priority].py<0) P[priority].py=0;P[priority].ct++;P[priority].at--;/* 除执行进程外,其他进程的操作*/for(i=1;i<=ready_q[0];i++)P[ready_q[i]].py+=1;/* 对阻塞队列和就绪队列赋值*//*? 进程被阻塞的时间BLOCKTIME,表示已阻塞的进程再等待BLOCKTIME个时间片后,进程将转换成就绪状态;*/for(i=1;i<=block_q[0];i++){ P[block_q[i]].bt-=1; /* 阻塞队列中的进程的blocktime-1 */ if (P[block_q[i]].bt==0) /* 如果该进程的blocktime=0,说明该进程需要进入就绪队列*/{ P[block_q[i]].st=1; /* 将该进程的st状态置1,将其从阻塞队列移入就绪队列*/block_q[0]--;ready_q[0]++;ready_q[ready_q[0]]=i;}}if(P[priority].at==0) /* 对当前执行进程,如果at=0说明执行完毕*/{ P[priority].st=0;P[priority].py=-1;}else if (P[priority].sb==P[priority].ct) /* 进程的阻塞时间STARTBLOCK,*//* 表示当进程再运行STARTBLOCK个时间片后,*//* 进程将进入阻塞状态;*/ { P[priority].st=-1;block_q[0]++;block_q[block_q[0]]=priority;}else /* 以上两个条件都不符合,直接进入就绪队列*/{ r eady_q[0]++;ready_q[ready_q[0]]=priority;}/* 运行一次后输出运行结果*/fprintf(fp,"\n\n RUNNING RPOC:%d TIMELICE:%d\n",priority-1,timeslice);fprintf(fp," READY_QUEUE :");for(i=1;i<=ready_q[0];i++)fprintf(fp,"->id%d",ready_q[i]-1);fprintf(fp,"\n");fprintf(fp," BLOCK_QUEUE :");for(i=1;i<=block_q[0];i++)fprintf(fp,"->id%d",block_q[i]-1);fprintf(fp,"\n");fprintf(fp,"===================================================== ===");fprintf(fp,"\n %-12s","ID");for(i=1;i<=n;i++)fprintf(fp,"%8d",i-1);fprintf(fp,"\n %-12s","PRIORITY");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].py);fprintf(fp,"\n %-12s","CPUTIME");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].ct);fprintf(fp,"\n %-12s","ALLTIME");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].at);fprintf(fp,"\n %-12s","STARTBLOCK");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].sb);fprintf(fp,"\n %-12s","BLOCKTIME");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].bt);fprintf(fp,"\n %-12s","STATE");for(i=1;i<=n;i++){ if(P[i].st==1)fprintf(fp,"%8s","READY");else if (P[i].st==0)fprintf(fp,"%8s","FINISH");elsefprintf(fp,"%8s","BLOCK");}fprintf(fp,"\n");}while((ready_q[0]!=0)||(block_q[0]!=0)); /* 循环结束条件:就绪队列和阻塞队列全为空*/}4.实验结果图1图25.实验结果本次实验的实验目的是通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解。

处理器调度之动态优先数调度算法

处理器调度之动态优先数调度算法

1 处理机调度1.1 实验内容及要求实验内容:按优先数调度算法实现处理器调度。

实验要求:能接受键盘输入的进程数、进程标识、进程优先数及要求运行时间,能显示每次进程调度的情况:运行进程、就绪进程和就绪进程的排列情况。

1.2 实验目的本实验模拟在单处理器环境下的处理器调度,加深了解处理器调度工作。

1.3 实验环境本实验的设计基于Windows7操作系统DevC++5.11环境,用C语言实现编程。

1.4 实验思路(1) 每个进程用一个PCB来代表。

PCB的结构为:进程名——作为进程标识。

优先数——赋予进程的优先数,调度时总是选取优先数大的进程先执行。

要求运行时间——假设进程需要运行的单位时间数。

状态——假设两种状态:就绪和结束,用R表示就绪,用E表示结束。

初始状态都为就绪状态。

指针——按优先数的大小把5个进程连成队列,用指针指出下一个进程PCB的首地址。

(2) 开始运行之前,为每个进程确定它的“优先数”和“要求运行时间”。

通过键盘输入这些参数。

(3) 处理器总是选择队首进程运行。

采用动态改变优先数的办法,进程每运行1次,优先数减1,要求运行时间减1。

(4) 进程运行一次后,若要求运行时间不等于0,则将它加入就绪队列,否则,将状态改为“结束”,退出就绪队列。

(5) 若就绪队列为空,结束,否则转到(3)重复。

1.5 数据结构与全局变量typedef struct pcb{int pname;//进程名int priority;//优先级int runTime;//所需时间int state;//状态struct pcb* next;//下一个进程控制块}PCB; //进程控制块int num;//存储进程数PCB readyHead;//头结点,不存储进程PCB *readyEnd;//指向尾结点的指针1.6 函数说明(1)主函数main()输入进程数并调createProcess()初始化进程;若有进程,则依次调用sortProcess()、runProcess()、printProcessLink()和printProcessInfo()。

动态高优先权实验报告

动态高优先权实验报告

实验一动态高优先权调度实验一、实验目的:通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解.提高自己的动手能力主要是通过自己去思考并自己的编码更进一步及更贴切的去理解弄明白动态优先权算法的模拟加深对进程概念和进程调度过程的工作流程及其原理!二.实验要求:1.在开是页面用户需要输入作业名,优先权级数,作业要求服务时间;2.每运行一个时间单位,作业的优先权级数减去自己的学号的后两位31mod5=1;3.在运行出的用户界面中需显示初始作业名,作业状态,优先权级数,需要服务的时间,已经运行的时间;4.每次调度前后显示作业队列。

三.实验内容利用C语言或JAVA或其它的语言(我用的用C语言)来实现对N 个进程采用动态优先权优先算法的进程调度。

每个用来标识进程的进程控制块PCB用结构来描述,包括以下字段:进程标识数ID进程优先数,并规定优先数越大的进程,其优先权越高进程已占用的CPU时间CUPTIME 进程还需占用的CPU时间ALLTIME。

当进程运行完毕时,ALLTIME变为0进程的阻塞时间STARTBLOCK,表示当进程再运行STARTBLOCK个时间片后,进程将进入阻塞状态。

进程被阻塞的时间BLOCKTIME,表示已阻塞的进程再等待BLOCKTIME个时间片后,将转换成就绪状态。

进程状态STATE.队列指针NEXT,用来将 PCB排成队列。

优先数改变的原则:进程在就绪队列中呆一个时间片,优先数增加1。

进程每运行一个时间片,优先数减1。

二、实验感想:在第次试验时,老师建议大家应该开始自己写程序,可以借鉴参考网上的代码,但绝不能单单的COPY网上的程序了,吃饭容易种饭难哈,自己写动态高优先权调度要比从网上写个代码简单修改一下难得多呀。

我自己开始编时摸不着头脑,从哪里下手。

我还是从网上下了个代码,然后认真的独立几遍,主要理解弄明白她的编写思路,好让我有个清晰的思路!然后自己写程序,不过其中碰见的很多的问题。

实验一 进程及其管理进程调度算法模拟,用动态优先数及时间片轮转法实现进程调度

实验一  进程及其管理进程调度算法模拟,用动态优先数及时间片轮转法实现进程调度

#include <stdio.h>//界面void menu(int arr[][5]){int i,j;printf("********进程相关信息如下:***********\n");for(i =0;i<5;i++){switch(i){case 0: printf("ID :");for(j=0;j<5;j++)printf("%d ",arr[i][j]);printf("\n");break;case 1: printf("PRI :");for(j=0;j<5;j++)printf("%d ",arr[i][j]);printf("\n");break;case 2: printf("CPUTIMEL:");for(j=0;j<5;j++)printf("%d ",arr[i][j]);printf("\n");break;case 3: printf("NEADTIME:");for(j=0;j<5;j++)printf("%d ",arr[i][j]);printf("\n");break;case 4: printf("STATE :");for(j=0;j<5;j++)printf("%d ",arr[i][j]);printf("\n");break;}}printf("\n*************进程调度过程如下:************\n\n");}//选出最大的优先级由大到小排列void sort(int a[],int b[],int c[]){int temp,t,s,i,j;for(i=0;i<4;i++){for(j=0;j<4-i;j++){if(a[j]<a[j+1]){temp =a[j];a[j]=a[j+1];a[j+1]=temp;t=b[j];b[j]=b[j+1];b[j+1]=t;s=c[j];c[j]=c[j+1];c[j+1]=s;}}}}void main(void){int i;int PRIORITY[5]={0};int CPUTIME[5]={0};int ALLTIME[5]={0};int ID[5]={0};//ID,PRI,CPUTIME,NEADTIME,STATEint arr[][5]={{0,1,2,3,4},{9,38,30,29,0},{0,0,0,0,0},{3,3,6,3,4},{0,0,0,0,0}};menu(arr);//二维数组的数据存到一维中for(i=0;i<5;i++){ID[i]=arr[0][i];PRIORITY[i]=arr[1][i];CPUTIME[i]=arr[2][i];ALLTIME[i]=arr[3][i];}while(1){if(ALLTIME[0]<=0){ID[0]=-1;}sort(PRIORITY,ID,ALLTIME);//对优先级由大到小排序if(ID[0]!=-1){printf("当前正运行的进程:%d\n",ID[0]);printf("当前的等待序列为: ");for(i=1;i<5;i++){if(ID[i]!=-1)printf("%d ",ID[i]);}printf("\n\n*******************************\n");}PRIORITY[0]-=3;CPUTIME[0]+=1;ALLTIME[0]-=1;}}。

动态优先权进程调度算法实验报告

动态优先权进程调度算法实验报告

《动态优先权进程调度算法》实验报告题目:动态优先权进程调度算法的模拟实现专业:班级:学号:姓名:日期:一﹑实验目的通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解。

二﹑实验内容与基本要求编制模拟动态优先权算法的程序,并给出的例子验证所编写的程序的正确性。

(1)用C语言实现对N个进程采用动态优先权算法的调度。

(2)每个用来标识进程的进程控制块PCB可用结构来描述,包括以下字段:✧进程标识数ID。

✧进程优先数PRIORITY,并规定优先数越大的进程,其优先权越高。

✧进程已占用CPU时间CPUTIME。

✧进程还需占用的CPU时间ALLTIME。

当进程运行完毕时,ALLTIME变为0。

✧进程的阻塞时间STARTBLOCK,表示当进程再运行STARTBLOCK个时间片后,进程将进入阻塞状态。

✧进程被阻塞的时间BLOCKTIME,表示已阻塞的进程再等待BLOCKTIME个时间片后,将转换成就绪状态。

✧进程状态STATE。

✧队列指针NEXT,用来将PCB排成队列。

(3)优先数改变的原则:✧进程在就绪队列中呆一个时间片,优先数增加1。

✧进程每运行一个时间片,优先数减3。

(4)假设在调度前,系统中有5个进程,它们得初始状态如下:为了清楚地观察每个进程的调度过程,程序应将每个时间片内的进程的情况显示出来,包括正在运行的进程,处于就绪队列中的进程和处于阻塞队列中的进程。

格式如下:RUNNING PROG:iREADY_QUEUE:->id1->id2BLOCK_QUEUE:->id3->id4==========================================================ID 0 1 2 3 4PRIORITY P0 P1 P2 P3 P4CPUTIME C0 C1 C3 C4 C5ALLTIME A0 A1 A2 A3 A4STARTBLOCK T0 T1 T2 T3 T4BLOCKTIME B0 B1 B2 B3 B4STATE S0 S1 S2 S3 S4三、实验报告内容1、动态优先权算法原理动态优先权是指,在创建进程时所赋予的优先权,是可以随进程的推进或随其等待时间的增加而改变的,以便获得更好的调度性能。

高优先权优先调度算法

高优先权优先调度算法

动态高优先权算法实验报告一、实验目的通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解。

提高自己的动手能力,主要是通过自己去思考并自己编码更进一步及更贴切的去理解弄明白动态优先权算法的模拟加深对进程概念和进程调度过程的工作流程及其原理!二、实验要求1.在运行界面里输入进程名称,进程优先级和进程时间;2.每运行一个时间单位,作业的优先权级数减一;3.在运行出的用户界面中显示初始作业名,作业状态,优先权级数,需要服务的时间,已经运行的时间;4.每次调度前后显示作业队列;三、实验内容动态优先权是指在创建进程时所赋予的优先权,是可以随着进程的推进或随其等待时间得增加而改变的。

实验内容利用C语言来实现对N个进程采用动态优先权优先算法的进程调度。

优先数改变的原则:进程每运行一个时间片,优先数减1。

四、实验结果登陆界面:图1 图2输入进程名字,进程优先数和进程时间:图3图4图5 图6图7 图8五、实验小结本次实验代码和基于时间片轮转算法代码是一样的,是在别人代码的基础上,结合自己对高优先权算法和时间片轮转算法的了解,通过switch语句把两者合二为一了,当输入1的时候,执行HighPriority函数,也就是动态高优先权函数。

在实现的过程中,使用for语句,限制进程数为5个:for (int i = 0; i != 5; ++i),,定义pt作为临时节点来创建链表,processes作为头结点来存储链表,psorted用来存放排序后的链表。

这次实验,在最初的时候,遇到了很大的麻烦,毕竟是改的别人代码,所以对代码理解的不是很透彻,但在同学们和老师的帮助下,终于调试成功了。

也使我更加明白了高优先权调度的过程。

六、附录#include <stdio.h>#include <stdlib.h>struct PCB{char p_name[20];int p_priority;int p_needTime;int p_runTime;char p_state;struct PCB* next;};void HighPriority();void RoundRobin();void Information();char Choice();struct PCB* SortList(PCB* HL);int main(){Information();char choice = Choice();switch(choice){case '1':system("cls");HighPriority();break;case '2':system("cls");RoundRobin();break;default:break;}system("pause");return 0;}void Information(){printf("\n\n");printf(" ********************************************* \n");printf(" 模拟进程调度算法\n");printf(" ********************************************* \n\n\n");printf(" 班级:软件测试10-02班\n");printf(" 姓名:林文\n");printf(" 学号:541013110224\n");printf(" 实验日期:2013年04月9日\n\n\n\n\n\n");printf(" 按回车键进入演示程序");getchar();system("cls");}char Choice(){printf("\n\n");printf(" ********************************************* \n");printf(" 进程调度演示\n");printf(" *********************************************\n\n\n");printf(" 1.演示最高优先数优先算法。

进程调度模拟设计——时间片轮转、优先级法

进程调度模拟设计——时间片轮转、优先级法

学号:课程设计课程名字系统软件开发实训A题目进程调度模拟设计——时间片轮转、优先级法学院专业班级姓名指导教师2014 年01 月17 日课程设计任务书学生姓名:专业班级:指导教师:工作单位:题目: 进程调度模拟设计——时间片轮转、优先级法初始条件:1.预备内容:阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解。

2.实践准备:掌握一种计算机高级语言的使用。

要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)1.模拟进程调度,能够处理以下的情形:⑴能够选择不同的调度算法(要求中给出的调度算法);⑵能够输入进程的基本信息,如进程名、优先级、到达时间和运行时间等;⑶根据选择的调度算法显示进程调度队列;⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。

2.设计报告内容应说明:⑴课程设计目的与功能;⑵需求分析,数据结构或模块说明(功能与框图);⑶源程序的主要部分;⑷测试用例,运行结果与运行情况分析;⑸自我评价与总结。

时间安排:设计安排3周:查阅、分析资料 1天系统软件的分析与建模 4天系统软件的设计 5天系统软件的实现 3天撰写文档 1天课程设计验收答辩 1天设计验收安排:设计周的第三周的指定时间到实验室进行上机验收。

设计报告书收取时间:课程设计验收答辩完结时。

(注意事项:严禁抄袭,一旦发现,抄与被抄的一律按0分记)指导教师签名: 2013 年 12 月 10日系主任(或责任教师)签名: 2013 年 12 月 10日进程调度模拟设计——时间片轮转、优先级法1设计目的1.1 阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解,能够使用其中的方法来进行进程调度模拟设计。

1.2 练掌握并运用时间片轮转和优先级法,掌握一种计算机高级语言的使用。

2 设计要求2.1 能够选择不同的调度算法(要求中给出的调度算法);2.2 能够输入进程的基本信息,如进程名、优先级、到达时间和运行时间等;2.3 根据选择的调度算法显示进程调度队列;2.4 根据选择的调度算法计算平均周转时间和平均带权周转时间。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

河南工业大学实验报告课程计算机操作系统实验名称高(动态)优先权优先的进程调度算法模拟系别信息科学与工程学院计算机科学系专业班级实验日期 2012-10-26姓名学号教师审批签字1.实验目的通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解。

2.实验环境装有操作系统Windows XP和开发工具VC++6.0,内存在256M以上的微机;或者:装有Linux(Fedora 7)操作系统和gcc编译器,内存在256M以上的微机。

3.实验内容(1)用C语言来实现对N个进程采用动态优先权优先算法的进程调度。

(2)每个用来标识进程的进程控制块PCB用结构来描述,包括以下字段:●进程标识数ID;●进程优先数PRIORITY,并规定优先数越大的进程,其优先权越高;●进程已占用的CPU时间CPUTIME;●进程还需占用的CPU时间NEEDTIME。

当进程运行完毕时,NEEDTIME变为0;●进程的阻塞时间STARTBLOCK,表示当进程再运行STARTBLOCK个时间片后,进程将进入阻塞状态;●进程被阻塞的时间BLOCKTIME,表示已阻塞的进程再等待BLOCKTIME个时间片后,进程将转换成就绪状态;●进程状态STATE;(READY, RUNNING, BLOCK, FINISH)●队列指针NEXT,用来将PCB排成队列。

(3)优先数改变的原则:●进程在就绪队列中呆一个时间片,优先数增加1;●进程每运行一个时间片,优先数减3。

(4)假设在调度前,系统中有5个进程,它们的初始状态如下:ID 0 1 2 3 4PRIORITY 9 38 30 29 0CPUTIME 0 0 0 0 0NEEDTIME 3 3 6 3 4STARTBLOCK 2 -1 -1 -1 -1BLOCKTIME 3 0 0 0 0STATE READY READY READY READY READY(5)为了清楚地观察进程的调度过程,程序应将每个时间片内的进程的情况显示出来,参照的具体格式如下:RUNNING PROCESS: $id0READY QUEUE: $id1->$id2BLOCK QUEUE: $id3->$id4FINISH QUEUE: $id0->$id1->$id2->$id3->$id4==================================================================ID PRIORITY CPUTIME NEEDTIME STATE STARTBLOCK BLOCKTIME0 XX XX XX XX XX XX1 XX XX XX XX XX XX2 XX XX XX XX XX XX3 XX XX XX XX XX XX4 XX XX XX XX XX XX==================================================================== 4.实验要求(1)将源程序(priority.c)和程序运行结果写入实验报告。

(2)将该算法执行过程与高响应比优先调度算法的执行过程进行比较。

5.实验过程及结果(1).代码:#include <stdio.h>#include <string.h>#include <stdlib.h>char *State[] = {"READY", "RUNNING", "BLOCK", "FINISH"};typedef struct PCB{i nt id;i nt priority;i nt cputime;i nt needtime;i nt startblock;i nt blocktime;c har *state;s truct PCB *next;s truct PCB *nt;}PCB;PCB *Ready, *Block, *Finish, *Runing, *ALL;PCB *findHighest();void insert(PCB *node, PCB *insert, int i);void ModifyPriority();void ModifyBlock();void BlockToReady();void Print();void FreeAllPCB();void init(){P CB *pro = (PCB *)malloc(sizeof(PCB));R eady->next = ALL = pro;p ro->id = 0;p ro->priority = 9;p ro->cputime = 0;p ro->needtime = 3;p ro->startblock = 2;p ro->blocktime = 3;p ro = pro->next = pro->nt = (PCB *)malloc(sizeof(PCB));p ro->id = 1;p ro->priority = 38;p ro->cputime = 0;p ro->needtime = 3;p ro->startblock = -1;p ro->blocktime = 0;p ro = pro->next = pro->nt = (PCB *)malloc(sizeof(PCB));p ro->id = 2;p ro->priority = 30;p ro->cputime = 0;p ro->needtime = 6;p ro->startblock = -1;p ro->blocktime = 0;pro = pro->next = pro->nt = (PCB *)malloc(sizeof(PCB)); p ro->id = 3;p ro->priority = 29;p ro->cputime = 0;p ro->needtime = 3;p ro->startblock = -1;p ro->blocktime = 0;p ro = pro->next = pro->nt = (PCB *)malloc(sizeof(PCB));p ro->id = 4;p ro->priority = 0;p ro->cputime = 0;p ro->needtime = 4;p ro->startblock = -1;p ro->blocktime = 0;p ro->next = pro->nt = NULL;}PCB *findHighest(){P CB *pro, *highest;P CB *propre = Ready;P CB *highpre = Ready;h ighest = pro = Ready->next;w hile(pro != NULL){if(pro->priority > highest->priority){highest = pro;highpre = propre;}propre = propre->next;pro = pro->next;}h ighpre->next = highest->next;h ighest->next = NULL;r eturn highest;}void insert(PCB *node,PCB *insert,int i) {n ode->state = State[i];n ode->next = insert->next;i nsert->next = node;}void ModifyPriority(){P CB *p;p = Ready->next;w hile(p !=NULL){p->priority++;p = p->next;}}void ModifyBlock(){P CB *p;p = Block->next;w hile(p !=NULL){p->blocktime--;p = p->next;}}void BlockToReady(){P CB *p, *pre, *node;p re = Block;p = pre->next;w hile(p != NULL){if(p->blocktime == 0){p->startblock--;node = p;p = pre->next = node->next;node->next = NULL;insert(node, Ready,0);}else{pre = pre->next;p = p->next;}}}void Print(){P CB *pro, *All;i f(Runing != NULL)printf("RUNNING PROCESS: $id%d\n", Runing->id);p rintf("READY QUEUE: ");p ro = Ready->next;w hile(pro != NULL){printf("->$id%d", pro->id);pro = pro->next;}p uts("");p rintf("BLOCK QUEUE: ");p ro = Block->next;w hile(pro != NULL){printf("->$id%d", pro->id);pro = pro->next;}p uts("");p rintf("FINISH QUEUE: ");p ro = Finish->next;w hile(pro != NULL){printf("->$id%d", pro->id);pro = pro->next;}p uts("");p rintf("===============================================================\n");p rintf("ID PRIORITY CPUTIME NEEDTIME STATE STARTBLOCK BLOCKTIME\n");A ll = ALL;w hile(All != NULL){printf("%d%10d%10d%10d%8s%10d%11d\n",All->id, All->priority, All->cputime, All->needtime, All->state, All->startblock, All->blocktime);All = All->nt;}}void FreeAllPCB(){f ree(Finish);}int main(void){P CB *pro;R eady = (PCB *)malloc(sizeof(PCB));B lock = (PCB *)malloc(sizeof(PCB));F inish = (PCB *)malloc(sizeof(PCB));R eady->next = NULL;B lock->next = NULL;F inish->next = NULL;i nit();w hile(Ready->next != NULL){pro = findHighest();Runing = pro;pro->state = State[1];pro->cputime++;pro->needtime--;if(pro->startblock > 0){pro->startblock--;}pro->priority -= 3;Print();ModifyBlock();ModifyPriority();BlockToReady();if(pro->needtime == 0){insert(pro, Finish, 3);Runing=NULL;}else{if(pro->startblock == 0){insert(pro, Block, 2);}else{insert(pro, Ready, 0);}Runing=NULL;}}P rint();F reeAllPCB();r eturn 0;}程序运行结果(2).试验中的问题将该算法执行过程与高响应比优先调度算法的执行过程进行比较。

相关文档
最新文档