设计一个按优先数调度算法实现处理器调度的程序
基于优先数的时间片轮转调度算法调度处理器
题目4基于优先数的时间片轮转调度算法调度处理器一、实验目的在采用多道程序设计的系统中,同时处于就绪态的进程往往有多个,当就绪态的进程数大于处理器的个数时,就需按照某种策略进行分配处理器。
本次设计模拟在单处理器情况下采用基于优先数的时间片轮转调度算法进行处理器调度,加深了解处理器调度工作过程。
二、实验内容及要求1、设计一个程序实现基于优先数的时间片轮转调度算法调度处理器。
2、假定系统有5个进程,每个进程用一个进程控制块PCB开代表,进程控制块的结构如下图所示:图1其中:进程名:作为进程的标识。
指针:进程按顺序排成循环链表,用指针指出下一个进程的进程控制块首地址,最后一个进程中的指针指出第一个进程的进程控制块首地址。
要求运行时间:假设进程需要运行的单位时间数。
已运行时间:假设进程已经运行的单位时间数,初值为0。
状态:可假设有两种状态,就绪状态和结束状态。
进程的初始状态都为就绪状态。
3、每次运行所设计的处理器调度程序调度进程之前,为每个进程任意确定它的要求运行时间。
4、此程序是模拟处理器调度,因此,被选中的进程并不实际启动运行,而是执行已运行时间+1来模拟进程的一次运行,表示进程已经运行过一个单位时间。
.5、在所设计的程序中应有显示或打印语句,能显示或打印每次被选中的进程名以及运行一次后进程队列的变化。
6、为进程任意确定要求运行时间,运行所设计的处理器调度程序,显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。
7、设有一个就绪队列,就绪进程按优先数(优先数范围0-100)由小到大排列(优先数越小,级别越高)。
当某一进程运行完一个时间片后,其优先级应下调(如优先数加2或3)。
8、例如一组进程如下表:三、实验报告1、程序中使用的数据结构及符号说明。
2、给出主要算法的流程图3、给出程序清单并附上注释4、打印程序运行时的初值和运行结果。
(运行一个进程输出一次结果)三、实验代码#include<>#include<>#include<>#define getpch(type) (type*)malloc(sizeof(type)) d:\n",i);printf("\n请输入作业的名字:");scanf("%s",l->name);printf("\n请输入作业的时间:");scanf("%d",&l->need_time);l->state = 'r'; d:\n",i);printf("\n请输入作业的名字:");scanf("%s",p->name);printf("\n请输入作业的时间:");scanf("%d",&p->need_time);p->state='r';p->worked_time=0;p->flag=0;l->link=p;l=l->link;}rear=l;rear->link=front;}void output().\n");getch();}if(s->state=='e'&&s->flag==0){printf("进程%s已经运行完成!\n\n",s->name);s->flag=1;}s=s->link;flag1=judge(s);}printf("--------------------------------------------\n"); }void input(){int i,num;printf("\n 请输入作业的个数:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n 作业号No.%d:\n",i); p=getpch(JCB);printf("\n 输入作业名:");scanf("%s",p->name);printf("\n 输入作业到达时刻:"); scanf("%f",&p->subtime);printf("\n 输入作业运行时间:"); scanf("%f",&p->runtime);printf("\n");p->state='w';p->link=NULL;sort();}}int space(){int l=0; JCB* jr=ready;while(jr!=NULL){l++;jr=jr->link;}return(l);}void disp(JCB* jr,int select){if (select==3) printf("\n 作业到达时间服务时间响应比运行时刻完成时刻周转时间带权周转时间\n");else printf("\n 作业到达时间服务时间运行时刻完成时刻周转时间带权周转时间\n");printf(" |%s\t",jr->name);printf(" |%.2f\t ",jr->subtime);printf(" |%.2f\t",jr->runtime);if (select==3&&p==jr) printf("|%.2f ",jr->Rp);if (p==jr){printf("|%.2f\t ",jr->;printf(" |%.2f ",jr->;printf(" |%.2f\t",jr->;printf(" |%.2f",jr->;}printf("\n");}int destroy(){printf("\n 作业[%s] 已完成.\n",p->name);free(p);return(1);}void check(int select){JCB* jr;printf("\n **** 当前正在运行的作业是:%s",p->name); disp(p,select);jr=ready;printf("\n ****当前就绪队列状态为:\n");while(jr!=NULL){jr->Rp=(jr->runtime+T-jr->subtime)/jr->runtime; disp(jr,select);jr=jr->link;}destroy();}void running(JCB* jr){if (T>=jr->subtime) jr->=T;else jr->=jr->subtime;jr->=jr->+jr->runtime;jr->=jr->>subtime;jr->=jr->jr->runtime;T=jr->;}int main(){int select=0,len,h=0;float sumTi=0,sumWi=0;printf("\t---*****************---\n"); printf("请选择作业调度算法的方式:\n"); printf("\ \n\n");printf("\t---*****************---\n"); printf("请输入作业调度算法序号(1-4):"); scanf("%d",&select);if (select==4){ creatJCB();RRget();}else{input();len=space();while((len!=0)&&(ready!=NULL)){h++;printf("\n 执行第%d个作业\n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';running(p);sumTi+=p->;sumWi+=p->;check(select);if (select==2&&h<len-1) SJFget();if (select==3&&h<len-1) HRNget();printf("\n 按任意一键继续......");getchar();getchar();}printf("\n\n 作业已经完成.\n");printf("\t 此组作业的平均周转时间:%.2f\n",sumTi/h);printf("\t 此组作业的带权平均周转时间:%.2f\n",sumWi/h);getchar();} }四、运行结果截图。
操作系统实验指导书
操作系统实验指导书一、实验说明1、实验目的实验是操作系统原理课程中不可缺少的重要教学环节,实验目的是使学生理论联系实际,使学生在实践探索中去发现问题、去解决问题,提高了学生获取知识和应用技术的能力,培养了学生分析和解决问题的能力。
《操作系统原理》要求理论与实践相结合,本门实验课程是对《操作系统原理》课堂教学的一个重要补充,与理论学习起着相辅相成的作用,是实施《操作系统原理》教学的一个重要组成部分。
通过本实验课的实践学习,可以增强本专业的学生对系统实现的认识。
对加深理解和掌握操作系统相关原理有重要帮助。
2、实验要求进一步了解和掌握操作系统原理,提高系统设计的能力。
对每一实验题目,应独立完成,并要求:·上机前,学生必须做好充分的实验准备工作,掌握与实验相关的背景知识,用任一种高级语言编写程序。
·上机时,认真调试,并观察、记录程序运行过程中出现的现象和问题。
·上机后,分析实验结果并写出实验报告。
3、实验报告要求每个实验(包括选做的)均应编写实验报告,学生实验后要写出严谨的、实事求是的、文字通顺的、字迹公整的实验报告。
实验报告应包括以下内容:(1)实验题目(2)实验目的(3)实验内容●程序中使用的数据结构及符号说明●流程图●源程序清单并附上注释(4)实验结果及分析●运行结果(必须是上面程序清单所对应输出的结果)●对运行情况所作的分析以及本次调试程序所取得的经验。
如果程序未能通过,应分析其原因。
二、实验内容实验一熟悉使用计算机系统一、实验名称:熟悉使用计算机系统二、实验目的与要求通过对Windows操作系统的使用,熟悉Windows操作系统中的基本概念,如单用户、多任务、进程和文件等,熟悉Windows中命令行方式下常用命令的使用方法;进一步熟悉TC语言与开发环境,为以后的实验打好基础。
三、实验内容1.开机后,熟悉Windows的界面(桌面、任务栏、开始按钮<点击后出现“开始”菜单>、我的电脑图标、回收站、我的文档)。
进程调度先来先服务时间片轮转法优先服务调
进程调度先来先服务时间片轮转法优先服务调度处理器调度免费下载C或C++/*标题:设计一:进程调度设计目的:进程管理是操作系统中的重要功能,用来创建进程、撤消进程、实现进程状态转换,它提供了在可运行的进程之间复用CPU的方法。
在进程管理中,进程调度是核心,因为在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态,当就绪进程个数大于处理器数目时,就必须依照某种策略决定哪些进程优先占用处理器。
本实验模拟在单处理器情况下的进程调度,目的是加深对进程调度工作的理解,掌握不同调度算法的优缺点。
设计题目:设计一个按先来先服务,算法时间片轮转法,优先数调度算法实现处理器调度的程序。
*//*亲爱的同学们,大家好。
欢迎访问我的百度空间,在此我向大家提供免费的资料,这是我们实习要做的。
主要是因为我看到很多下载都要金币,而我自己没有金币,不爽。
现在我提供免费下载,做个好人。
复制到VC++时可能有些格式问题,稍微修改一下就OK了,程序本身不存在问题的。
大三第一个学期实习的哦*//*先来先服务:是一种最简单的调度算法,每次调度都从后备作业或者进程当中选择一个或者多个最先进入该队列的作业或进程,将它们调入内存,为它们分配资源、创建进程,然后放入就绪队列。
当调用FCFS算法时,系统为它们分配处理机,让它们运行。
该算法的优点是比较利于长作业(进程),而缺点是不利于短作业(进程)。
算法时间片轮转法:系统将所有的就绪进程按照先来先服务的原则排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片。
当执行完时间片时,计时器就会发出中断请求,调度程序就会停止该进程的执行,并把它送往就绪队列的末尾;然后再把处理机分配给就绪队列中新的队首进程,同时也分配时间片给它。
这样保证就绪队列中的所有进程在一个给定的时间片当中都能够获得一个时间片的处理机执行时间。
而时间片的大小最好取适中的,即略大于一次典型的交互所需时间。
优先数调度算法:该方法又分成两种算法分支,分别是非抢占式优先权算法和抢占式优先权调度算法。
操作系统实验——动态优先级进程调度实验报告
1.实验名称:动态优先权调度过程中就绪队列的模拟2.实验要求:采用动态优先权的进程调度算法,用C语言编程模拟调度过程中每个时间片内的就绪队列。
3.实验内容:(1)每个进程控制块PCB用结构描述,包括以下字段:*进程标识符id*进程优先数priority,并规定优先数越大的进程,其优先权越高。
*进程已占用的CPU时间cputime*进程还需占用的CPU时间alltime,当进程运行完毕时,aiitime变为0*进程的阻塞时间startblock,当进程再运行startblock个时间片后,进程将进入阻塞状态*进程被阻塞的时间blocktime,已阻塞的进程再等待blocktime个时间片后,将转换成就绪状态*进程状态state*队列指针next,将PCB排成队列。
2)调度前,系统中有五个进程,它们的初始状态如下:3)进程在就绪队列呆一个时间片,优先数增加1。
4)进程每运行一个时间片,优先数减3。
5)按下面格式显示每个时间片内就绪队列的情况:READY_QUEUE:->id1->id24.任务分析进程控制块用结构体来表示,包含它的各项属性。
建立两个队列:一个就绪队列,一个阻塞队列。
创建一个进程控制块表示当前正在运行的进程。
程序开始运行时,所有进程都在就绪队列中。
当startblock减少到0时,进程进入阻塞队列。
在阻塞队列中的进程,当blocktime减少到0时,转入就绪队列。
在就绪队列中的进程,如果优先级比当前正在执行的进程高,就可以取代当前进程获取时间片。
当前进程如果运行完毕,就绪队列中优先级最高的进程就可以成为新当前进程。
5.程序流程图#include〈iostream〉#include〈string〉usingnamespace std;#define LEN5typedefenum STATE{READYBLOCKEND}STATE;//定义进程控制块typedefstruct PCB{int id;int priority;int cputime;int alltime;int startblock;int blocktime;STATE state;}PCB;//定义队列typedefstruct queue{int si ze;PCB*data[LEN];}Queue;PCB ps[LEN];PCB*cp; //进程最大数量//进程状态//就绪//阻塞//完成//进程标识符//进程优先级//已占用的CPU时间//还需占用的CPu时间//阻塞时间//被阻塞时间//进程状态//队列中进程的数量//进程的指针//进程数组//当前正在运行的进程6.程序清单Queue rQueue,bQueue;//就绪队列和阻塞队列//就绪队列按优先级降序排序(使用了冒泡排序法)void rQueueSort(){ PCB*temp;for(int i=0;i<rQueue.size-1;i++){for(int j=0;j<rQueue.size-1-i;j++){if(rQueue.data[j]-〉priority<rQueue.data[j+1]-〉priority){temp=rQueue.data[j];rQueue.data[j]=rQueue.data[j+1];}}rQueue.dataj+1]=temp;}}//初始化void init(){//给进程赋值for(int i=0;i<LEN;i++){ps[i].id=i;ps[i].state=READY;ps[i].cputime=0;ps[i].alltime=3;ps[i].blocktime=0;ps[i].startblock=T;}ps[0].priority=9;ps[1].priority=38;ps[2].priority=30;ps[3].priority=29;ps[4].priority=0;ps[2].alltime=6;ps[4].alltime=4;ps[0].startblock=2;ps[0].blocktime=3;cp=NULL;//当前进程赋空bQueue.size=0;//阻塞队列没有进程for(int i=0;i<LEN;i++){bQueue.data[i]=NULL;rQueue.data[i]=&ps[i];}rQueue.size=5;//所有进程全部进入就绪队列rQueueSort();//对就绪队列排序}//打印void print(){cout〈〈"\nRUNNINGPROG:";if(cp!=NULL){cout〈〈cp->id;}cout<<"\nREADY_QUEUE:";for(int i=0;i<rQueue.size;i++){cout〈〈"-〉"〈〈rQueue.data[i]-〉id; }cout<<"\nBLOCK_QUEUE:";for(int i=0;i<bQueue.size;i++){cout〈〈"-〉"〈〈bQueue.data[i]-〉id; }cout〈〈"\n"<<endl;cout<<"ID\t\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].id<<"\t";}cout<<"\nPRI0RITY\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].priority〈〈"\t";}cout<<"\nCPUTIME\t\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].cputime〈〈"\t";}cout<<"\nALLTIME\t\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].alltime〈〈"\t";}cout<<"\nSTARTBLOCK\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].startblock<<"\t";}cout<<"\nBLOCKTIME\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].blocktime<<"\t";}cout<<"\nSTATE\t\t";for(int i=0;i<LEN;i++){if(ps[i].state==READY){cout<<"READY"<<"\t";}elseif(ps[i].state==BLOCK){cout<<"BLOCK"<<"\t";}elseif(ps[i].state==END){cout〈〈"END"<<"\t";}}cout〈〈endl;}//出队,返回进程指针PCB*pop(Queue*q){PCB*temp;if(q-〉size>0){temp=q-〉data[0];//取出队首进程for(int i=0;i<q-〉size-1;i++){q-〉data[i]=q-〉data[i+1];//其他进程依次向前移动}q->size__;return temp;//返回队首进程}return NULL;}//入队void push(Queue*q,PCB*p){if(q_>size<LEN){q_>data[q_〉size]=p;//将入队的进程放在队尾q_>size++;}return;}//运行进程void run(){if(rQueue.size〉0||bQueue.size〉0){if(cp==NULL){//程序一开始运行时,从就绪队列取出首进程cp=pop(&rQueue);}//当前进程没有结束,但优先级比就绪队列首进程低if(cp_〉alltime〉0&&cp_>priority<rQueue.data[0]_〉priority){}push(&r Queue,c//改变进程状态//从就绪队列取出新的当前进程//修改当前进程的状态 //将当前进程加入阻塞队列 //从就绪队列取出新的当前进程{//当前进程的startblock 为正数时//运行一次减一个时间片//减到0时,修改进程状态//每运行一个时间片//就绪队列中的进程优先级+1//每运行一个时间片//阻塞队列中的进程blocktime-1//将当前进程放入就绪队列 //就绪队列队首进程成为当前进程if (cp-〉alltime==0){cp->state =END ;cp=pop(&rQueue); }//如果当前进程运行结束//startblock 为0,标志着当前进程要进入阻塞状态if (cp —>startblock==0&&cp —>blocktime>0){cp —>state=BLOCK ; push(&bQueue,cp); cp=pop(&rQueue); }elseif (cp —>startblock>0)cp —>st artblock 一; }cp —>alltime ——;if (cp —>alltime==0){cp —>state=END ;for (int i=0;i<rQueue.size;i++){rQueue.data[i]-〉priority++; }for (int i=0;i<bQueue.size;i++){if (bQueue.data[i]-〉blocktime>0){bQueue.data[i]-〉blocktime--; }//当阻塞队列队首进程blocktime 为0时if (bQueue.size 〉0&&bQueue.data[0]-〉blocktime==0){bQueue.data[0]-〉state=READY ;//修改进程状态push(&rQueue,pop(&bQueue));//将阻塞队列首进程取出,放入就绪队列cp —〉priority-=3;//修改当前进程的优先级cp —>cputime++; //当前进程占用CPU 时间片+1 if (cp —>alltime>0){//当前进程还需运行的时间片-1}//每运行一个时间片,就绪队列排一次序rQueueSort();} }//主函数int main(){init();//初始化 print();//打印进程信息 while (1){_sleep(1000);if (rQueue.size==0&&bQueue.size==0){//当两个队列都为空时,结束程序cp-〉state=END ;break ; }run();//运行进程 print();//打印进程信息 }return 0; }7.实验过程记录m 匚:\WINDQWS\system32\cmd.exe程序开始执行,当前进程是优先级最高的1号进程,1号进程的优先级减3、cputime++、执行几次之后,1号进程执行完毕而且优先级也不是最高的了,所以优先级为33的2号进程成为当前进程,开始执行。
进程调度模拟设计——先来先服务、优先级法教材
学号:课程设计进程调度模拟设计——先来题目先服务、优先级法学院计算机科学与技术专业班级姓名指导教师吴利军2013 年 1 月16 日课程设计任务书学生姓名:专业班级:指导教师:吴利军工作单位:计算机科学与技术学院题目: 进程调度模拟设计——先来先服务、优先级法初始条件:1.预备内容:阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解。
2.实践准备:掌握一种计算机高级语言的使用。
要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)1.模拟进程调度,能够处理以下的情形:⑴能够选择不同的调度算法(要求中给出的调度算法);⑵能够输入进程的基本信息,如进程名、优先级、到达时间和运行时间等;⑶根据选择的调度算法显示进程调度队列;⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。
2.设计报告内容应说明:⑴需求分析;⑵功能设计(数据结构及模块说明);⑶开发平台及源程序的主要部分;⑷测试用例,运行结果与运行情况分析;⑸自我评价与总结:i)你认为你完成的设计哪些地方做得比较好或比较出色;ii)什么地方做得不太好,以后如何改正;iii)从本设计得到的收获(在编写,调试,执行过程中的经验和教训);iv)完成本题是否有其他方法(如果有,简要说明该方法);时间安排:设计安排一周:周1、周2:完成程序分析及设计。
周2、周3:完成程序调试及测试。
周4、周5:验收、撰写课程设计报告。
(注意事项:严禁抄袭,一旦发现,一律按0分记)指导教师签名:年月日系主任(或责任教师)签名:年月日进程调度模拟设计——先来先服务、优先级法1、背景:当计算机系统是多道程序设计系统时,通常会有多个进程或线程同时竞争CPU。
只要有两个或更多的进程处于就绪状态,这种情形就会发生。
如果只有一个CPU可用,那么就必须选择下一个要运行的进程。
在操作系统中,完成选择工作的这一部分称为调度程序,该程序使用的算法成为调度算法。
操作系统实验
《操作系统》实验指导书德州学院计算机系实验一理解和认识操作系统的三种接口1.目的和要求MS-DOS和Windows是市场上普及率很高的操作系统,本实验的目的是让读者从操作系统理论的观点加深对现代操作操作系统的接口设计的理解。
2.实验内容①熟悉DOS的基本命令,包括md,cd,copy,move,del,deltree,type 等的使用a、当前目录下建立子目录MYTEMP和MYTEMP2,将当前目录设定为MYTEMP;b、在当前目录下创建新文件B.BAT,其内容为:清除屏幕内容,显示当前DOS版本;c、使用type命令显示B.BAT的内容,检查正确后,执行它;d、拷贝B.BAT到路径MYTEMP中;e、删除MYTEMP2中的文件B.BAT,删除目录MYTEMP2;f、使用deltree命令删除MYTEMP②理解WINDOWS下的编程接口原理,了解WINAPI,利用WINAPI实现WINDOWS 下的打印。
a、登录进入Windowsb、在“开始”菜单中单击“程序”-“Microsoft Visual Studio 6.0”-“MicrosoftVisual C++ 6.0”命令,进入Visual C++ 窗口。
c、在File菜单单击New Workspace...命令,创建PrintApp.dsw项目文件。
d、在File菜单单击New C++ Soure file命令,创建新的原文件。
e、输入如实验运行结果中所示的源代码,调试、编译并运行。
f、观察执行结果,理解各个函数的功能。
3.实验环境Windows操作系统和Visual C++6.0专业版或企业版实验二复习用C语言编制程序一、实验内容选择一个计算机系统,熟悉该系统的操作命令,且掌握该计算机系统的使用方法。
二、实验目的配合操作系统课程的学习,模拟实现操作系统的功能,有助于对操作系统的理解。
操作系统功能的模拟实现可以在计算机系统的终端上进行,也可以在一台微型计算机上进行。
OS课设之CPU调度算法地模拟实现
CPU调度算法的模拟实现一、设计目的利用C++编写CPU调度算法,实现先来先服务调度算法FCFS、优先级调度算法PS、短作业优先调度算法SJF、时间片轮转调度算法RR的运行过程和实现的结果,针对模拟进程,利用编写的CPU调度算法对需要运行的进程进行调度。
进行算法评价,计算平均周转时间和平均等待时间。
二、设计要求针对模拟进程,利用CPU调度算法进行调度,最后要进行算法评价,计算平均周转时间和平均等待时间,并且输出调度结果和输出算法评价指标。
调度所需的进程参数由输入产生(手工输入或者随机数产生)。
三、设计说明CPU调度决策可在如下4种情况环境下发生:(1)当一个进程从运行切换到等待状态(如:I/O请求,或者调用wait等待一个子进程的终止)(2)当一个进程从运行状态切换到就绪状态(如:出现中断)(3)当一个进程从等待状态切换到就绪状态(如:I/O完成)(4)当一个进程终止时对于第1和4两种情况,没有选择而只有调度。
一个新进程(如果就绪队列中已有一个进程存在)必须被选择执行。
对于第2和第3两种情况,可以进行选择。
当调度只能发生在第1和4两种情况下时,称调度是非抢占的(nonpreemptive)或协作的(cooperative);否则,称调度方案为抢占的(preemptive)。
采用非抢占调度,一旦CPU分配给一个进程,那么该进程会一直使用CPU直到进程终止或切换到等待状态。
抢占调度对访问共享数据是有代价(如加锁)的,有可能产生错误,需要新的机制(如,同步)来协调对共享数据的访问。
抢占对于操作系统内核的设计也有影响。
在处理系统调用时,内核可能忙于进程活动。
这些活动可能涉及要改变重要内核数据(如I/O队列)。
因为根据定义中断能随时发生,而且不能总是被内核所忽视,所以受中断影响的代码段必须加以保护以避免同时访问。
操作系统需要在任何时候都能够接收中断,否则输入会丢失或输出会被改写。
为了这些代码段不被多个进程同时访问,在进入时就要禁止中断,而在退出时要重新允许中断。
OS课设之CPU调度算法的模拟实现
O S课设之C P U调度算法的模拟实现集团标准化工作小组 #Q8QGGQT-GX8G08Q8-GNQGJ8-MHHGN#CPU调度算法的模拟实现一、设计目的利用C++编写CPU调度算法,实现先来先服务调度算法FCFS、优先级调度算法PS、短作业优先调度算法SJF、时间片轮转调度算法RR的运行过程和实现的结果,针对模拟进程,利用编写的CPU调度算法对需要运行的进程进行调度。
进行算法评价,计算平均周转时间和平均等待时间。
二、设计要求针对模拟进程,利用CPU调度算法进行调度,最后要进行算法评价,计算平均周转时间和平均等待时间,并且输出调度结果和输出算法评价指标。
调度所需的进程参数由输入产生(手工输入或者随机数产生)。
三、设计说明CPU调度决策可在如下4种情况环境下发生:(1)当一个进程从运行切换到等待状态(如:I/O请求,或者调用wait等待一个子进程的终止)(2)当一个进程从运行状态切换到就绪状态(如:出现中断)(3)当一个进程从等待状态切换到就绪状态(如:I/O完成)(4)当一个进程终止时对于第1和4两种情况,没有选择而只有调度。
一个新进程(如果就绪队列中已有一个进程存在)必须被选择执行。
对于第2和第3两种情况,可以进行选择。
当调度只能发生在第1和4两种情况下时,称调度是非抢占的(nonpreemptive)或协作的(cooperative);否则,称调度方案为抢占的(preemptive)。
采用非抢占调度,一旦CPU分配给一个进程,那么该进程会一直使用CPU直到进程终止或切换到等待状态。
抢占调度对访问共享数据是有代价(如加锁)的,有可能产生错误,需要新的机制(如,同步)来协调对共享数据的访问。
抢占对于操作系统内核的设计也有影响。
在处理系统调用时,内核可能忙于进程活动。
这些活动可能涉及要改变重要内核数据(如I/O队列)。
因为根据定义中断能随时发生,而且不能总是被内核所忽视,所以受中断影响的代码段必须加以保护以避免同时访问。
设计一个按优先数调度算法实现处理器调度的程序可以输入进程的数量
题目:设计一个按优先数调度算法实现处理器调度的程序(可以自己定义进程的数量)提示:(1)假定系统有5个进程,每个进程用一个PCB来代表。
PCB的格式为:进程名、指针、要求运行时间、优先数、状态。
进程名——P1~P5。
指针——按优先数的大小把5个进程连成队列,用指针指出下一个进程PCB的首地址。
要求运行时间——假设进程需要运行的单位时间数。
优先数——赋予进程的优先数,调度时总是选取优先数大的进程先执行。
状态——假设两种状态,就绪,用R表示,和结束,用E表示。
初始状态都为就绪状态。
(2) 每次运行之前,为每个进程任意确定它的“优先数”和“要求运行时间”。
(3) 处理器总是选队首进程运行。
采用动态改变优先数的办法,进程每运行1次,优先数减1,要求运行时间减1。
(4) 进程运行一次后,若要求运行时间不等于0,则将它加入队列,否则,将状态改为“结束”,退出队列。
(5) 若就绪队列为空,结束,否则,重复(3)。
2.流程图:(1)主程序流程图:始开调用初始化子程序调用运行子程序束结init()流程图:(2)子程序始开i定i=0i<num输出操作提ID,pri,runtime输stategetchar()i=i+1结束流程图:max_pri_process()子程序(3)开始i,key,max=100定i=0i<numpcblist[i].state=return -1max<pcblist[i].pri&&cblist[i].state=='R'key=imax=pcblist[i].prii=i+1pcblist[key].state=='F' keyreturnreturn -1结流程图:show()子程序(4).开i定输出提i=0i<numpcblist[iID,pri,runtime,state 提示按键继i=i+1结(5)子程序run()流程图:开始i,j,t定j=0j<numt+=pcblist[j].runtimej=j+1输出提(shogetchar()j=0j<tmax_pri_process()!=-1pcblist[max_pri_process()].state='r'i=0i<numpcblist[i].state=='pcblist[i].runtime-- pcblist[i].pri-=1pcblist[i].runtime==0pcblist[i].state='pcblist[i].state='getchar()show()i=i+1j=j+13.源程序清单///按优先数调度算法实现处理器调度的程序#include stdio.h#include string.hint num;struct PCB{char name;//进程名int runtime;//要求运行时间int pri;//优先数char state;//状态,R-就绪,F-结束};struct PCB pcblist[100];//定义进程控制块数组void init()//PCB初始化子程序{int i;for(i=0;i<num;i++){printf(PCB[%d]:进程名优先级运行时间\n,i+1);//为每个进程任意指定pri和runtime scanf(%s%d%d, &pcblist[i].name, &pcblist[i].pri, &pcblist[i].runtime);pcblist[i].state='R';//进程初始状态均为就绪getchar();//接收回车符}}int max_pri_process()//确定最大优先级进程子程序{int max=-100;//max为最大优先数,初始化为-100int i;int key;for(i=0;i<num;i++){if(pcblist[i].state=='r')//r为辅助状态标志,表示正在运行return -1;//返回-1elseif(max<pcblist[i].pri&&pcblist[i].state=='R')//从就绪进程中选取优先数最大的进程{max=pcblist[i].pri;//max存放每次循环中的最大优先数key=i;//将进程号赋给key}}具有最大优先数的进程若已运行完毕if(pcblist[key].state=='E')//return -1;//则返回-1elsereturn key;//将key作为返回值返回}void show()//显示子程序{int i;printf(\***进程名优先级运行时间状态***\n);printf(-------------------------------------------------\n);for(i=0;i<num;i++)//依次显示每个进程的名、优先数、要求运行时间和状态{printf(*** %s m ? %s***\n, &pcblist[i].name, pcblist[i].pri,pcblist[i].runtime, &pcblist[i].state);}牰湩晴尨按任意键继续...\n);}void run()//进程运行子程序{int i,j;int f;int h;int g;int t=0;//t为运行次数for(j=0;j<num;j++){t+=pcblist[j].runtime;}//运行次数即为各个进程运行时间之和printf(\处理之前的状态:\n);show(); //调用show()子程序显示运行前PCB的情况getchar();//等待输入回车符f=t;g=t;for(j=0;j<t;j++){while(max_pri_process()!=-1)//具有最大优先数的进程没有运行完,让其运行{pcblist[max_pri_process()].state='r';//将其状态置为r,表示其正在运行}for(i=0;i<num;i++){if(pcblist[i].state=='r'){ if(pcblist[i].pri>=1) pcblist[i].pri-=1;//将当前运行进程的优先数减1 pcblist[i].runtime--;{if(pcblist[i].runtime==0)pcblist[i].state='E';//运行完则将该进程状态置为结束elsepcblist[i].state='R';//未运行完将其状态置为就绪}h=f-(--g);,h);运行%d这是第牰湩晴尨show();//显示每次运行后各PCB的情况getchar();//等待回车进入下一次运行}}}}void main()//按动态优先数调度主程序{ 牰湩晴尨请输入要运行进程的数目:);scanf(%d,&num);//输入进程数init();//初始化各个进程PCBrun(); //进程调度模拟}。
设计一个按优先数调度算法实现处理器调度的程序(可以输入进程的数量)
设计一个按优先数调度算法实现处理器调度的程序算法简介进程调度算法是决定进程在处理器上执行顺序的一种方法。
按照进程的优先级大小来安排每个进程在处理器上的运行顺序。
常见的有以下几种进程调度算法:•先来先服务(First Come, First Serve, FCFS)算法•短作业优先(Shortest Job First, SJF)算法•优先级调度算法•时间片轮转调度(Round Robin, RR)算法本文介绍如何设计一个按优先数调度算法实现处理器调度的程序。
优先级调度算法中,每个进程都分配有一个优先级,等待CPU资源时CPU会选择优先级最高的进程先执行。
在本次设计中,我们将使用最高优先级调度算法实现最高优先级的任务先被处理。
设计思路该程序实现的主要思路如下:1.构建进程模型。
结构体包括进程名称、进程 PID、进程优先级等成员变量。
2.生成不同优先级的进程,并将其存入队列中。
3.运用算法从队列中选择优先级最高并等待执行的进程。
4.执行选择的进程并从队列中移除。
5.循环执行步骤 3 和 4 直到所有进程都被完成。
Markdown 代码实现首先我们需要创建一个结构体 Process,结构体中包含有进程名,进程PID和进程优先级。
struct Process {string pName; // 进程名称int PID; // 进程PIDint priority; // 进程优先级};从用户输入中获取需要生成的进程数量,并构造进程队列。
```markdown int n; // 进程的数量 queue processes; // 进程队列,按优先级升序排列 cin >> n; // 获取进程数量 srand(time(NULL)); // 设定随机数发生器的起始值 for (int i = 1; i <= n; ++i) { Process process; process.pName =。
(完整版)操作系统短作业优先调度算法汇总,推荐文档
五、主要数据结构及其说明
算法的基本概念和原理:本次课程设计主要是采用短作业优先算法进程的 进程调度过程。短作业优先调度算法,是指对短作业或短进程优先调度的算法。 他们可以分别用于作业调度和进程调度,短作业优先的调度算法是从后备队列 中选择一个或若干个估计运行时间最短的作业,将他们调入内存运行。而短进 程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程,将处理 机分配给他,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处 理机时再度重新调度。本程序采用了非抢占式短作业优先调度。而非抢占式这 种方式,一旦把处理机分配给某进程后,便让该进程一直执行,直至该进程完 成或发生某事件而被阻塞时,才再把处理机分配给其它进程,决不允许某进程 抢占已经分配出去的处理机。这种调度方式的优点是实现简单,系统开销小, 适用于大多数的批处理系统环境。但它难以满足紧急任务的要求——立即执行, 因而可能造成难以预料的后果。因此,在要求比较严格的实时系统中,不宜采 用这种调度方式。本课程设计主要是在满足要求多道单处理机的情况下进行短 作业的优先调度。
4
达的,那么首先执行该进程;之后就比较进程的服务时间,谁的服务时间短就 先执行谁(如果服务时间相同则看它们的到达时间,到达时间短的先执行);如 果到达时间和服务时间相同,则按先来先服务算法执行。
六、程序运行结果
1 进入操作界面如下 2 输入进程的信息
3 各时刻进程的状态
5
6
4 进程信息
5 平均带权周转时间界面
float run_time;
run_time=Process[i].WholeTime;
j=1;
while((j<N)&&(Process[i].ArrivalTime==Process[j].ArrivalTime)) //判断是
实验一___处理器调度(设计一个按时间片轮转法实现处理器调度的程序)介绍
实验一处理器调度一、实验内容选择一个调度算法,实现处理器调度。
二、实验目的在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。
当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。
本实习模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。
三、实验题目第二题:设计一个按时间片轮转法实现处理器调度的程序。
[提示]:(1)假定系统有五个进程,每一个进程用一个进程控制块PCB来代表。
进程控制块的格式为:其中,Q1,Q2,Q3,Q4,Q5。
指针——进程按顺序排成循环队列,用指针指出下一个进程的进程控制块的首地址最后一个进程的指针指出第一个进程的进程控制块首地址。
要求运行时间——假设进程需要运行的单位时间数。
已运行时间——假设进程已经运行的单位时间数,初始值为“0”。
状态——有两种状态,“就绪”和“结束”,初始状态都为“就绪”,用“R”表示。
当一个进程运行结束后,它的状态为“结束”,用“E”表示。
(2) 每次运行所设计的处理器调度程序前,为每个进程任意确定它的“要求运行时间”。
(3) 把五个进程按顺序排成循环队列,用指针指出队列连接情况。
另用一标志单元记录轮到运行的进程。
例如,当前轮到P2执行,则有:标志单元K1K2K3K4K5PCB1 PCB2 PCB3 PCB4 PCB5(4)处理器调度总是选择标志单元指示的进程运行。
由于本实习是模拟处理器调度的功能,所以,对被选中的进程并不实际的启动运行,而是执行:已运行时间+1来模拟进程的一次运行,表示进程已经运行过一个单位的时间。
请同学注意:在实际的系统中,当一个进程被选中运行时,必须置上该进程可以运行的时间片值,以及恢复进程的现场,让它占有处理器运行,直到出现等待事件或运行满一个时间片。
在这时省去了这些工作,仅用“已运行时间+1”来表示进程已经运行满一个时间片。
(5)进程运行一次后,应把该进程的进程控制块中的指针值送到标志单元,以指示下一个轮到运行的进程。
设计一个按优先数调度算法实现处理器调度的进程
设计一个按优先数调度算法实现处理器调度的进程
一.处理器调度的简介
处理器调度是指在若干作业并发处理时,对处理器分配工作的动态过程。
它是操作系统中的一种重要技术,其主要功能是控制并发作业的执行,使他们得到公平的分配,正确的完成执行,以达到有效利用处理机资源,
提高系统的工作效率。
处理器调度技术包括:处理机调度算法、处理机调
度技术等。
处理机调度算法就是基于计算机系统的工作机制,根据不同的作业在
处理机上的执行情况,系统在不同的阶段,根据量的不同,采用不同的算法,按优先级、分时等原则进行处理机调度,使作业在不同的阶段得到公
平的分配,以达到有效利用处理机资源,提高系统工作效率的目的。
按优先数调度算法( Priority Scheduling Algorithm )是指根据作
业的优先级先后来分配处理机资源,使作业能够按照优先级依次被处理,
使得系统性能有所提高。
1.处理器调度的算法流程
按优先数调度算法的处理器调度的过程,如下:
首先,从队列中取出一个作业,检查是否具有最高优先级,如果是,
则将其分配给处理机,否则,该作业放回队列,继续下一步判断;
其次,在没有作业可以处理时,处理机将停止运转。
优先级调度算法实验报告
优先级调度算法实验报告院系:****************学院班级:***********姓名:***学号:************一、实验题目:优先级调度算法二、实验目的进程调度是处理机管理的核心内容。
本实验要求用高级语言编写模拟进程调度程序,以便加深理解有关进程控制快、进程队列等概念,并体会和了解优先级算法的具体实施办法。
三、实验内容1.设计进程控制块PCB的结构,通常应包括如下信息:进程名、进程优先数(或轮转时间片数)、进程已占用的CPU时间、进程到完成还需要的时间、进程的状态、当前队列指针等。
2.编写优先级调度算法程序3.按要求输出结果。
四、实验要求每个进程可有三种状态;执行状态(RUN)、就绪状态(READY,包括等待状态)和完成状态(FINISH),并假定初始状态为就绪状态。
(一)进程控制块结构如下:NAME——进程标示符PRIO/ROUND——进程优先数NEEDTIME——进程到完成还需要的时间片数STATE——进程状态NEXT——链指针注:1.为了便于处理,程序中进程的的运行时间以时间片为单位进行计算;2.各进程的优先数或,以及进程运行时间片数的初值,均由用户在程序运行时给定。
(二)进程的就绪态和等待态均为链表结构,共有四个指针如下:RUN——当前运行进程指针READY——就需队列头指针TAIL——就需队列尾指针FINISH——完成队列头指针五、实验结果:六、实验总结:首先这次实验的难度不小,它必须在熟悉掌握数据结构的链表和队列的前提下才能完成,这次实验中用了三个队列,就绪队列,执行队列和完成队列,就绪队列中的优先级数是有序插入的,当进行进程调度的时候,需要先把就绪队列的队首节点(优先级数最大的节点)移入执行队列中,当执行进程结束后,判断该进程是否已经完成,如果已经完成则移入完成队列,如果没有完成,重新有序插入就绪队列中,这就是这次实验算法的思想。
附录(算法代码):#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct node{char name[20]; /*进程的名字*/int prio; /*进程的优先级*///int cputime; /*CPU执行时间*/int needtime; /*进程执行所需要的时间*/char state; /*进程的状态,W--就绪态,R--执行态,F--完成态*/struct node *next; /*链表指针*/}PCB;PCB *ready=NULL,*run=NULL,*finish=NULL; /*定义三个队列,就绪队列,执行队列和完成队列*/int num;void GetFirst(); /*从就绪队列取得第一个节点*/void Output(); /*输出队列信息*/void InsertPrio(PCB *in); /*创建优先级队列,规定优先数越小,优先级越高*/ void InsertTime(PCB *in); /*时间片队列*/void InsertFinish(PCB *in); /*时间片队列*/void PrioCreate(); /*优先级输入函数*///void TimeCreate(); /*时间片输入函数*/void Priority(); /*按照优先级调度*///void RoundRun(); /*时间片轮转调度*/void main(){printf("优先数调度算法\n");printf("请输入要创建的进程数目:");scanf("%d",&num);PrioCreate();Priority();Output();}void GetFirst() /*取得第一个就绪队列节点*/{run = ready;if(ready!=NULL){run ->state = 'R';ready = ready ->next;run ->next = NULL;}}void Output() /*输出队列信息*/{PCB *p;p = ready;printf("进程名\t优先级\t需要时间\t进程状态\n");while(p!=NULL){printf("%s\t%d\t%d\t\t%c\t\n",p->name,p->prio,p->needtime,p->state);p = p->next;}p = finish;while(p!=NULL){printf("%s\t%d\t%d\t\t%c\t\n",p->name,p->prio,p->needtime,p->state);p = p->next;}p = run;while(p!=NULL){printf("%s\t%d\t%d\t\t%c\t\n",p->name,p->prio,p->needtime,p->state);p = p->next;}}void InsertPrio(PCB *in) /*创建优先级队列,规定优先数越小,优先级越低*/ {PCB *fst,*nxt;fst = nxt = ready;if(ready == NULL) /*如果队列为空,则为第一个元素*/{in->next = ready;ready = in;}else /*查到合适的位置进行插入*/{if(in ->prio >= fst ->prio) /*比第一个还要大,则插入到队头*/{in->next = ready;ready = in;}else{while(fst->next != NULL) /*移动指针查找第一个别它小的元素的位置进行插入*/{nxt = fst;fst = fst->next;}if(fst ->next == NULL) /*已经搜索到队尾,则其优先级数最小,将其插入到队尾即可*/{in ->next = fst ->next;fst ->next = in;}else /*插入到队列中*/{nxt = in;in ->next = fst;}}}}void InsertFinish(PCB *in) /*将进程插入到完成队列尾部*/{PCB *fst;fst = finish;if(finish == NULL){in->next = finish;finish = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void PrioCreate() /*优先级调度输入函数*/{PCB *tmp;int i;printf("输入进程名字,进程所需时间和优先级数:\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar(); /*吸收回车符号*/scanf("%d",&(tmp->needtime));getchar();scanf("%d",&(tmp->prio));// tmp ->cputime = 0;tmp ->state ='W';//tmp ->prio = 20 - tmp->needtime; /*设置其优先级,需要的时间越多,优先级越低*/InsertPrio(tmp); /*按照优先级从高到低,插入到就绪队列*/}}void Priority() /*按照优先级调度,每次执行一个时间片*/{int flag = 1;GetFirst();while(run != NULL) /*当就绪队列不为空时,则调度进程如执行队列执行*/ {Output(); /*输出每次调度过程中各个节点的状态*/while(flag){run->prio -= 3; /*优先级减去三*///run->cputime++; /*CPU时间片加一*/run->needtime--;/*进程执行完成的剩余时间减一*/if(run->needtime == 0)/*如果进程执行完毕,将进程状态置为F,将其插入到完成队列*/{run ->state = 'F';// run->count++; /*进程执行的次数加一*/InsertFinish(run);flag = 0;}else /*将进程状态置为W,入就绪队列*/{run->state = 'W';//run->count++; /*进程执行的次数加一*///InsertTime(run);//再次插入就绪队列尾部InsertPrio(run);flag = 0;}}flag = 1;GetFirst(); /*继续取就绪队列队头进程进入执行队列*/ }。
实验4优先级调度算法设计实验
实验4 优先级调度算法设计实验1.实验目的在操作系统的调度算法中,优先级调度算法是一种常用的调度算法。
采用优先级调度算法要求每个进程都有一个优先级与其关联,具有最高优先级的进程会分配到CPU,具有相同优先级的进程按FCFS(First Come First Served)顺序调度。
本次实验要求在Linux操作系统上用C语言编写和调试一个基于优先级优先运行算法的进程调度程序。
2.实验内容1)优先级简介动态优先数是指在进程创建时先确定一个初始优先数,以后在进程运行中随着进程特性的改变不断修改优先数,这样,由于开始优先数很低而得不到CPU的进程,就能因为等待时间的增长而优先数变为最高而得到CPU运行。
例如:在进程获得一次CPU后就将其优先数减少1,或者进程等待的时间超过某一时限时增加其优先数的值,等等。
2)详细设计优先权调度算法:1.设定系统中有五个进程,每一个进程用一个进程控制块(PCB)表示,进程队列采用链表数据结构。
进程控制块包含如下信息:进程名、优先数、需要运行时间、已用CPU时间、进程状态等等。
在每次运行设计的处理调度程序之前,由终端输入五个进程的“优先数”和“要求运行时间”。
进程的优先数及需要的运行时间人为地指定,进程的运行时间以时间片为单位进行计算。
2.采用优先权调度算法,将五个进程按给定的优先数从大到小连成就绪队列。
用头指针指出队列首进程,队列采用链表结构。
处理机调度总是选队列首进程运行。
采用动态优先数办法,进程每运行一次优先数减“1”,同时将已运行时间加“1”。
进程运行一次后,若要求运行时间不等于已运行时间,则再将它加入就绪队列;否则将其状态置为“结束”,且退出就绪队列。
“就绪”状态的进程队列不为空,则重复上面6,7步骤,直到所有进程都成为“结束”状态。
3.在设计的程序中有输入语句,输入5个进程的“优先数”和“要求运行时间”,也有显示或打印语句,能显示或打印每次被选中进程的进程名、运行一次后队列的变化,以及结束进程的进程名。
最高优先数优先”调度算法
最高优先数优先”调度算法1.初始状态下,系统中存在多个作业等待执行。
2.每个作业都有一个优先级,通常用一个数字来表示,数字越大表示优先级越高。
作业的优先级可以根据不同的因素来确定,如作业的类型、作业的重要程度等。
3.调度程序首先选择具有最高优先级的作业,并将其分配给可执行的处理器。
4.一旦作业被分配给处理器,它将开始执行。
5.在作业执行的过程中,调度程序会根据作业的实际执行情况来决定是否切换到更高优先级的作业。
如果一个新的作业到达系统,并且它的优先级比当前正在执行的作业更高,调度程序将中断当前作业的执行,将处理器分配给新的作业。
6.当一个作业完成执行后,调度程序会根据优先级来选择下一个要执行的作业。
使用最高优先数优先调度算法有以下一些特点和优势:1.执行效率高:最高优先数优先调度算法能够保证具有最高优先级的作业被尽快地执行,从而提高系统的响应速度和执行效率。
2.灵活性强:由于优先级可以根据不同的因素来确定,因此最高优先数优先调度算法具有很大的灵活性。
它可以根据不同的需求来确定作业的执行顺序,从而满足用户的不同需求。
3.适应性好:最高优先数优先调度算法能够适应不同的系统负载和作业类型。
它可以根据系统中的实际情况来动态地调整作业的优先级,从而提高系统的整体性能。
然而,最高优先数优先调度算法也存在一些不足之处:1.可能导致饥饿问题:由于最高优先数优先调度算法总是优先选择优先级最高的作业执行,因此优先级较低的作业可能会长时间地等待,甚至会发生饥饿现象。
2.优先级的确定可能存在问题:确定作业的优先级是非常关键的,如果优先级的设置不合理,可能会导致系统的负载不均衡,一些重要的作业无法及时得到执行。
总的来说,最高优先数优先调度算法是一种简单而高效的作业调度算法。
它可以根据作业的优先级来动态地分配处理器资源,从而提高系统的响应速度和执行效率。
然而,在实际应用中,我们需要根据系统的具体情况来选择合适的调度算法,以满足系统的实际需求。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
开始 定义 i,key,max=100
i=0 i<num
pcblist[i].state==’r’ return -1
max<pcblist[i].pri&&p cblist[i].state=='R'
max=pcblist[i].pri key=i i=i+1
pcblist[key].state=='F' return -1
int t=0;//t 为运行次数 for(j=0;j<num;j++) {t+=pcblist[j].runtime;}//运行次数即为各个进程运行时间之和 printf("\nbefore run,the conditon is:\n"); show(); //调用 show()子程序显示运行前 PCB 的情况 getchar();//等待输入回车符
return -1;//返回-1
else if(max<pcblist[i].pri&&pcblist[i].state=='R')//从就绪进程中选取优先数最大的进程 { max=pcblist[i].pri;//max 存放每次循环中的最大优先数 key=i;//将进程号赋给 key
}
} if(pcblist[key].state=='F')//具有最大优先数的进程若已运行完毕 return -1;//则返回-1 else//否则 return key;//将 key 作为返回值返回
2.程序中使用的数据结构及符号说明: #define num 5//假定系统中进程个数为 5
struct PCB{ char ID;//进程名 int runtime;//要求运行时间 int pri;//优先数 char state; //状态,R-就绪,F-结束
}; struct PCB pcblist[num];//定义进程控制块数组
for(j=0;j<t;j++)
{while(max_pri_process()!=-1)//具有最大优先数的进程没有运行完,让其运行
{
pcblist[max_pri_process()].state='r';//将其状态置为 r,表示其正在运行
}
for(i=0;i<num;i++)
{if(pcblist[i].state=='r')
贵阳学院 电子与通信工程学院
实验报告
2012~2013 学年第 2 学期
课
程
计算机操作系统原理
实 验 名 称 设计一个按优先数调度算法实现处理器调度的程序
学生姓名
张
琛
学
号
101118401047
专业班级
通信工程
指导教师
李
毅
2013 年 6 月
题目:设计一个按优先数调度算法实现处理器调度的程序
1. 提示: (1)假定系统有 5 个进程,每个进程用一个 PCB 来代表。PCB 的格式为: 进程名、指针、要求运行时间、优先数、状态。 进程名——P1~P5。 指针——按优先数的大小把 5 个进程连成队列,用指针指出下一个进程 PCB 的首地 址。 要求运行时间——假设进程需要运行的单位时间数。 优先数——赋予进程的优先数,调度时总是选取优先数大的进程先执行。 状态——假设两种状态,就绪,用 R 表示,和结束,用 E 表示。初始状态都为就绪 状态。
j=j+1
输出提示 show() getchar()
j=0 j<t
max_pri_process()!=-1 pcblist[max_pri_process()].state='r'
i=0 i<num
pcblist[i].state=='r '
pcblist[i].pri-=1 pcblist[i].runtime--
#define num 5//假定系统中进程个数为 5
struct PCB {
char ID;//进程名 int runtime;//要求运行时间 int pri;//优先数 char state; //状态,R-就绪,F-结束 }; struct PCB pcblist[num];//定义进程控制块数组
{
pcblist[i].pri-=1;//将当前运行进程的优先数减 1
pcblist[i].runtime--;//要求运行时间减 1
{
if(pcblist[i].runtime==0) pcblist[i].则将该进程状态置为结束
else pcblist[i].state='R';//未运行完将其状态置为就绪
return key
结束
(4)子程序 show()流程图:
开始 定义 i 输出提示
i=0 i<num
输 出 pcblist[i] 的 ID,pri,runtime,state
提示按键继续 i=i+1 结束
(5)子程序 run()流程图:
开始 定义 i,j,t
j=0 j<num t+=pcblist[j].runtime
pcblist[i].runtime==0
pcblist[i].state='F '
pcblist[i].state='R '
show() getchar()
i=i+1
j=j+1 结束
4.源程序清单
//按优先数调度算法实现处理器调度的程序 #include "stdio.h" #include "string.h"
}
void show()//显示子程序 {int i;
printf("\n ID pri runtime state\n"); printf("-------------------------------------------------\n"); for(i=0;i<num;i++)//依次显示每个进程的名、优先数、要求运行时间和状态 {
}
show();//显示每次运行后各 PCB 的情况 getchar();//等待回车进入下一次运行 } } } }
void main()//按动态优先数调度主程序 {
init();//初始化各个进程 PCB run();//进程调度模拟 }
int max_pri_process()//确定最大优先级进程子程序 {
int max=-100;//max 为最大优先数,初始化为-100 int i; int key;
for(i=0;i<num;i++) {if(pcblist[i].state=='r')//r 为辅助状态标志,表示正在运行
printf("%s%6d%8d %s\n",&pcblist[i].ID,pcblist[i].pri,pcblist[i].runtime,&pcblist[i].state); } printf(" press any key to continue...\n"); }
void run()//进程运行子程序 {int i,j;
(2) 每次运行之前,为每个进程任意确定它的“优先数”和“要求运行时间”。 (3) 处理器总是选队首进程运行。采用动态改变优先数的办法,进程每运行 1 次,优先
数减 1,要求运行时间减 1。 (4) 进程运行一次后,若要求运行时间不等于 0,则将它加入队列,否则,将状态改为“结
束”,退出队列。 (5) 若就绪队列为空,结束,否则,重复(3)。
3.流程图: (1)主程序流程图:
开始
调用初始化子程序
(2)子程序 init()流程图:
调用运行子程序 结束
开始 定义 i
i=0 i<num 输出操作提示 输入 ID,pri,runtime state=’R’ getchar() i=i+1 结束
(3) 子程序 max_pri_process()流程图:
void init()//PCB 初始化子程序 {
int i; for(i=0;i<num;i++) {
printf("PCB[%d]:ID pri runtime \n",i+1);//为每个进程任意指定 pri 和 runtime scanf("%s%d%d",&pcblist[i].ID,&pcblist[i].pri,&pcblist[i].runtime); pcblist[i].state='R';//进程初始状态均为就绪 getchar();//接收回车符 } }