操作系统作业调度实验报告
作业调度_实验报告

实验名称作业调度实验内容1、设计可用于该实验的作业控制块;2、动态或静态创建多个作业;3、模拟先来先服务调度算法和短作业优先调度算法。
3、调度所创建的作业并显示调度结果(要求至少显示出各作业的到达时间,服务时间,开始时间,完成时间,周转时间和带权周转时间);3、比较两种调度算法的优劣。
实验原理一、作业作业(Job)是系统为完成一个用户的计算任务(或一次事物处理)所做的工作总和,它由程序、数据和作业说明书三部分组成,系统根据该说明书来对程序的运行进行控制。
在批处理系统中,是以作业为基本单位从外存调入内存的。
二、作业控制块J C B(J o b C o nt r o l Bl o ck)作业控制块JCB是记录与该作业有关的各种信息的登记表。
为了管理和调度作业,在多道批处理系统中为每个作业设置了一个作业控制块,如同进程控制块是进程在系统中存在的标志一样,它是作业在系统中存在的标志,其中保存了系统对作业进行管理和调度所需的全部信息。
在JCB中所包含的内容因系统而异,通常应包含的内容有:作业标识、用户名称、用户帐户、作业类型(CPU 繁忙型、I/O 繁忙型、批量型、终端型)、作业状态、调度信息(优先级、作业已运行时间)、资源需求(预计运行时间、要求内存大小、要求I/O设备的类型和数量等)、进入系统时间、开始处理时间、作业完成时间、作业退出时间、资源使用情况等。
三、作业调度作业调度的主要功能是根据作业控制块中的信息,审查系统能否满足用户作业的资源需求,以及按照一定的算法,从外存的后备队列中选取某些作业调入内存,并为它们创建进程、分配必要的资源。
然后再将新创建的进程插入就绪队列,准备执行。
四、选择调度算法的准则1).面向用户的准则(1) 周转时间短。
通常把周转时间的长短作为评价批处理系统的性能、选择作业调度方式与算法的重要准则之一。
所谓周转时间,是指从作业被提交给系统开始,到作业完成为止的这段时间间隔(称为作业周转时间)。
作业调度实验报告

作业调度实验报告一、实验目的1.掌握作业调度的概念和基本原则;2.理解作业调度算法的原理和实现方式;3.熟悉作业调度过程中的各种参数和指标;4.进一步了解操作系统中的进程调度机制。
二、实验环境本次实验使用的操作系统环境为Windows平台。
三、实验内容1.实现一个简单的作业调度算法,根据作业的重要性和执行时间进行优先级排序;2.设计一个作业队列,模拟一系列作业的到达和执行过程;3.根据作业调度算法,将作业分配给CPU执行,并统计作业的等待时间、完成时间等指标;4.进行多次实验,比较不同调度算法之间的性能差异。
四、实验步骤1.首先,设计一个作业类,包括作业的名称、重要性、到达时间和执行时间等属性;2.定义一个作业队列,用于存储到达的作业,并按照到达时间进行排序;3.实现一个简单的作业调度算法,根据作业的重要性和执行时间进行优先级排序;4.设计一个CPU类,用于执行作业队列中的作业,并记录作业的等待时间、完成时间等指标;5.模拟一系列作业的到达和执行过程,将作业调度给CPU执行,并记录相关指标;6.分别使用不同的调度算法进行多次实验,比较各自的性能差异。
五、实验结果与分析通过多次实验,得到了不同调度算法下的作业等待时间、完成时间等指标,并进行了比较。
结果发现,在作业执行时间相同时,按照作业的重要性进行优先级排序的算法,能够使得较重要的作业尽早执行,因而整体的作业等待时间和完成时间较短。
而对于作业执行时间不一致的情况,采用短作业优先算法,可以使作业平均等待时间较短,但在一些较长的作业上可能会存在饥饿现象。
综合考虑作业的重要性和执行时间,采用带权重的优先级队列算法可以获得较好的调度效果。
六、实验总结通过本次实验,我深入了解了作业调度的概念、原理和实现方式。
通过对比不同调度算法的性能差异,对于实际的作业调度过程具有一定的指导意义。
此外,通过实验设计和代码实现,我也提高了编程和分析问题的能力。
总体而言,本次实验使我对操作系统中的作业调度有了更为深刻的理解,并提高了我的实践能力。
操作系统实验报告进程调度

操作系统实验报告进程调度操作系统实验报告:进程调度引言在计算机科学领域中,操作系统是一个重要的概念,它负责管理和协调计算机系统中的各种资源,包括处理器、内存、输入/输出设备等。
其中,进程调度是操作系统中一个非常重要的组成部分,它负责决定哪个进程在何时获得处理器的使用权,以及如何有效地利用处理器资源。
实验目的本次实验的目的是通过对进程调度算法的实验,深入理解不同的进程调度算法对系统性能的影响,并掌握进程调度算法的实现方法。
实验环境本次实验使用了一台配备了Linux操作系统的计算机作为实验平台。
在该计算机上,我们使用了C语言编写了一些简单的进程调度算法,并通过模拟不同的进程调度场景进行了实验。
实验内容1. 先来先服务调度算法(FCFS)先来先服务调度算法是一种简单的进程调度算法,它按照进程到达的顺序进行调度。
在本次实验中,我们编写了一个简单的FCFS调度算法,并通过模拟多个进程同时到达的情况,观察其对系统性能的影响。
2. 短作业优先调度算法(SJF)短作业优先调度算法是一种根据进程执行时间长度进行调度的算法。
在本次实验中,我们编写了一个简单的SJF调度算法,并通过模拟不同长度的进程,观察其对系统性能的影响。
3. 时间片轮转调度算法(RR)时间片轮转调度算法是一种按照时间片大小进行调度的算法。
在本次实验中,我们编写了一个简单的RR调度算法,并通过模拟不同时间片大小的情况,观察其对系统性能的影响。
实验结果通过实验,我们发现不同的进程调度算法对系统性能有着不同的影响。
在FCFS 算法下,长作业会导致短作业等待时间过长;在SJF算法下,长作业会导致短作业饥饿现象;而RR算法则能够较好地平衡不同进程的执行。
因此,在实际应用中,需要根据具体情况选择合适的进程调度算法。
结论本次实验通过对进程调度算法的实验,深入理解了不同的进程调度算法对系统性能的影响,并掌握了进程调度算法的实现方法。
同时,也加深了对操作系统的理解,为今后的学习和研究打下了良好的基础。
操作系统实验报告-作业调度

作业调度一、实验目的1、对作业调度的相关内容作进一步的理解。
2、明白作业调度的主要任务。
3、通过编程掌握作业调度的主要算法。
二、实验内容及要求1、对于给定的一组作业, 给出其到达时间和运行时间,例如下表所示:2、分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。
3、计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。
测试数据workA={'作业名':'A','到达时间':0,'服务时间':6} workB={'作业名':'B','到达时间':2,'服务时间':50} workC={'作业名':'C','到达时间':5,'服务时间':20} workD={'作业名':'D','到达时间':5,'服务时间':10} workE={'作业名':'E','到达时间':12,'服务时间':40} workF={'作业名':'F','到达时间':15,'服务时间':8}运行结果先来先服务算法调度顺序:['A', 'B', 'C', 'D', 'E', 'F']周转时间:带权周转时间:短作业优先算法调度顺序:['A', 'D', 'F', 'C', 'E', 'B']周转时间:带权周转时间:1.响应比高者优先算法调度顺序:['A', 'D', 'F', 'E', 'C', 'B']周转时间:带权周转时间:五、代码#encoding=gbkworkA={'作业名':'A','到达时间':0,'服务时间':6,'结束时间':0,'周转时间':0,'带权周转时间':0}workB={'作业名':'B','到达时间':2,'服务时间':50}workC={'作业名':'C','到达时间':5,'服务时间':20}workD={'作业名':'D','到达时间':5,'服务时间':10}workE={'作业名':'E','到达时间':12,'服务时间':40}workF={'作业名':'F','到达时间':15,'服务时间':8}list1=[workB,workA,workC,workD,workE,workF]list2=[workB,workA,workC,workD,workE,workF]list3=[workB,workA,workC,workD,workE,workF]#先来先服务算法def fcfs(list):resultlist = sorted(list, key=lambda s: s['到达时间'])return resultlist#短作业优先算法def sjf(list):time=0resultlist=[]for work1 in list:time+=work1['服务时间']listdd=[]ctime=0for i in range(time):for work2 in list:if work2['到达时间']<=ctime:(work2)if len(listdd)!=0:li = sorted(listdd, key=lambda s: s['服务时间'])(li[0])(li[0])ctime+=li[0]['服务时间']listdd=[]return resultlist#响应比高者优先算法def hrrn(list):time=0resultlist=[]for work1 in list:time+=work1['服务时间']listdd=[]ctime=0for i in range(time):for work2 in list:if work2['到达时间']<=ctime:work2['等待时间']=ctime-work2['到达时间'](work2)if len(listdd)!=0:li = sorted(listdd, key=lambda s: (s['等待时间']+s['服务时间'])/s['服务时间'])(li[-1])(li[-1])ctime+=li[-1]['服务时间']listdd=[]return resultlist#调度顺序def shunxu(resultlist,miaoshu):print(miaoshu)ddsx=[]for work in resultlist:for d,x in ():if ('gb2312')==u'作业名':(x)#print ('gb2312')+":"+str(x)print(u'调度顺序:'+str(ddsx))turnaroundTime(resultlist)#平均周转时间及平均带权周转时间def turnaroundTime(resultlist):time=0for work in resultlist:work['结束时间']=work['服务时间']+timetime=work['结束时间']work['周转时间']=work['结束时间']-work['到达时间']work['带权周转时间']=work['周转时间'] / work['服务时间']zzsj=0dqzzsj=0for work in resultlist:zzsj+=work['周转时间']dqzzsj+=work['带权周转时间']print('周转时间:'+str(zzsj*len(resultlist)))print('带权周转时间:'+str(dqzzsj*len(resultlist))) print('')shunxu(fcfs(list1),'先来先服务算法')shunxu(sjf(list2),'短作业优先算法')shunxu(hrrn(list3),'响应比高者优先算法')。
操作系统试验报告一处理机调度

实验课程名称:实验项目名称处理机调度 实验成绩实验者专业班级名且另IJ同组者实验日期年 月 日第一部分:实验分析与设计(可加页)一、 实验内容描述(问题域描述)实验目的:掌握处理机调度的相关内容,对进程调度算法有深入理解。
实验内容:模拟实现进程调度功能。
实验要求:1、任选一种高级语言实现;2、选择1-2种调度算法;3、能够输入进程的基本信息,如进程名、提交时间、预估运行时间等;4、根据选择的调度算法显示进程调度顺序;5、显示完成调度后每个进程的开始时间、完成时间呢、周转时间,带权周转时间;6、计算平均周转时间和平均带权周转时间。
二、 实验基本原理与设计(包括实验方案设计,实验手段的确定,试验步骤等,用硬件逻辑或者算法描述) 数据结构:一个作业的描述结构: struct WORK {int num;//进程序号startTim;//开始时间 upTim;//提交时间 offTim;//结束时间 costTim;//耗费时间长度 Ti;//周转时间 Tr;//带权周转时间输出模块float floatfloat floatfloat float };功能说明:输入模块、输出模块:负责进程的输入及模拟结果的输出;处理机调度函数调用模块:选择调用算法完成进程调度;先入先出算法模拟模块、短进程优先算法模拟模块:实际完成模拟调度功能;相关时间计算模块:计算开始时间、结束时间,周转时间,带权周转时间。
三、主要仪器设备及耗材硬件:pc机;软件:windows2007旗舰版、VS 2010开发环境。
第二部分:实验调试与结果分析(可加页)一、实验源程序:# include <iostream>using namespace std;struct WORK{int num;//进程序号float startTim;//开始时间float upTimJ/提交时间float offTim;//结束时间float costTim;//耗费时间长度float Ti;〃周转时间float Tr;//带权周转时间};void FIFO(WORK *workspace,int workNum);void SJF(WORK *workspace,int workNum);void SUM(WORK *workspace,int workNum,float *T,float *W);int main(){int num;float upTim;float costTim;int workNum;cout<<"请输入需要被调度的作业的数目:"<<endl;cin>>workNum;WORK *workspace=new WORK[workNum];cout<<"请依次输入需要被调度的作业(输入格式:作业序号作业提交时间(用数字表示) 执行时间):"<<endl;int n=0;while(cin>>num>>upTim>>costTim && n<workNum){workspace[n].num=num;workspace[n].upTim=upTim;workspace[n].costTim=costTim;n++;}cin.clear();cin.sync();cout<<"作业序号\t作业提交时间\t执行时间):"<<endl;for(int i=0;i<workNum;i++) {cout<<workspace[i].num<<"\t\t"<<workspace[i].upTim<<"\t\t<<workspace[i].costTim<<endl;/****************** 选择算法,执行算法,结果输出*****************/int cho=0;float * T=new float[0],* W=new float[0];cout<<"请选择调度算法:"<<endl;cout<<0<<"--->FIFO\n"<<1<<"--->最短优先"<<endl;cin>>cho;switch(cho){case 0:FIFO(workspace,workNum);SUM(workspace,workNum,T,W);break;case 1:SJF(workspace,workNum);SUM(workspace,workNum,T,W);break;}cout<<"执行顺序"<<"\t"<<"提交时间"<<"\t"<<"执行时间"<<"\t"<<"开始时间"<<"\t"<<"结束时间"<<endl;for(int i=0;i<workNum;i++) {cout<<workspace[i].num<<"\t\t"<<workspace[i].upTim<<"\t\t"<<workspace[i].costTim <<"\t\t"<<workspace[i].startTim<<"\t\t"<<workspace[i].offTim<<endl;}cout<<"平均周转时间:"<<(*T)/workNum<<"\t 平均带权周转时间:"<<(*W)/workNum<<endl;system("PAUSE"); return 0;}void FIFO(WORK *workspace,int workNum)for(int i=0;i<workNum-1;i++) 〃按提交时间排序for(int j=0;j<workNum-1;j++)if(workspace[j].upTim>workspace[j+1].upTim) 〃大数沉底{WORK temp;temp=workspace[j+1];workspace[j+1]=workspace[j];workspace[j]=temp;}}void SJF(WORK *workspace,int workNum){float MinUptime=0;//最早的提交时间FIFO(workspace,workNum);//先按提交时间排序MinUptime=workspace[0].upTim+workspace[0].costTim;for(int i=0;i<workNum-1;i++) 〃按照最短的作业时间排序for(int j=1;j<workNum-1;j++){if(workspace[j].upTim<MinUptime&&workspace[j+1].upTim<MinUptime) {if(workspace[j].costTim>workspace[j+1].costTim) 〃提交时间大且耗时多的作业沉底{WORK temp;temp=workspace[j+1];workspace[j+1]=workspace[j]; workspace[j]=temp;}} else {MinUptime=workspace[j].upTim+workspace[j].costTim;//更新}}}void SUM(WORK *workspace,int workNum,float *T,float *W){*T=0;*W=0;for(int i=0;i<workNum;i++)//计算开始时间、结束时间,周转时间,带权周转时间{ if(i==0)//计算第一个作业{workspace[i].startTim=workspace[i].upTim;workspace[i].offTim=workspace[i].upTim+workspace[i].costTim;workspace[i].Ti=workspace[i].offTim-workspace[i].upTim;workspace[i].Tr=workspace[i].Ti/workspace[i].costTim;}else//计算第一个作业基础上的其他作业相关时间{if(workspace[i-1].offTim<workspace[i].upTim)workspace[i].startTim=workspace[i].upTim;elseworkspace[i].startTim=workspace[i-1].offTim;workspace[i].offTim=workspace[i].costTim+workspace[i].startTim; workspace[i].Ti=workspace[i].offTim-workspace[i].upTim; workspace[i].Tr=workspace[i].Ti/workspace[i].costTim; }*T+=workspace[i].Ti;//计算平均周转时间 *W+=workspace[i].Tr;//计算平均带权周转时间 } } 二、 实验结果及分析(包括结果描述、实验现象分析、影响因素讨论、综合分析和结论等)测试用例一结果:请依次前A 需要被洞度的作止:葡人格式;作出序号 执行时间M 1 10 2,眼糟翎要被调度的作业(输入格式:作业序号1 10 2作止提交升间1用道字表示)|2 10.2 1 1? 10a 4 0a 5 L 10a 5 0a 2■(此序]作业提父H J 闫 L 10Z 10.23 10.4k10.5青选择调度算法:0——>FIF0 i-—>最超优先 执行时间), 暨 1 0.5 0.3a 二顺序提交时间 执行时间开始时间结束时间1 10210 12,10.2i 12 13 卜 10.4 8.5 13 13.E 口 1Q.5 0.3平均周转时间.2.8 平均带权周转时间吗.26岛北旺京银继纨 -±3.513.8邛业序与 作北提交时、日h 1M 执行时间)।21«.2 13 10.4 0.5 MIB.E情选区调度算法,同——>FIF0 口一》最短优先 0.3执行顺序 提交时间1 10 执行时间 2开始时间10 结克时间 124IB.E 0.3 12 12.3 10.4 0.5 12.3 12.81M-21句周转时间:2.45平均带权周转时间:3.8512.JS13=8日数据细撷处理机调度废锚纵员或吐理挑洞庭模物n京葡a 需要神话后日作业的数诸输妻萼猫调康的作斗的豹目:2 1M-2 1 □ 10.4 0.5 4 10-5 0,3回作业提交时间(用数字表。
操作系统实验5-调度

实验五调度一、基本信息二、实验内容在设计一个按优先级进行调度的算法(1(2的进程(3)调度时,总是选择优先级最高的执行,并采用动态调度:每运行一次优先级减1,估计运行时间减1(4)进程运行一次后,若剩余的运行时间不为0,且优先级低于就绪队列中的进程,则状态变为ready,并选择一个进程使用CPU;若剩余的运行时间为0,则状态变为完成(5)如就绪队列不空,则重复(3)(4)直到所有进程都结束三、实验目的通过实验,巩固和加深对进程调度的理解,以及各种调度算法的基本实现思想。
四、设计思路和流程图(1)用一个结构体构造进程块,记录进程的各个属性,优先级和估计运行时间随机产生(2)创建一个进程块链表,每个节点表示一个进程块。
用head指针表示链表头部,用curPCB表示当前CPU调度的进程块(3)遍历链表,找到优先级最高的进程“运行”(4)重复调度进直到就绪队列中没有进程时,程序运行结束五、主要数据结构及其说明#include <cstdio>#include <random>#include <time.h>struct PCB{int id;int priority;//数值越大,优先级越高PCB* nextPCB;//指向就绪队列中下一个进程的PCB首址int probTime;//估计运行时间int state;//0: ready, 1: running, 2:finished};void main(){srand((unsigned)time(0));struct PCB *temp = new struct PCB;const int cnt = 3;struct PCB *head = temp;for(int i=0; i<cnt; ++i){temp->id = i;temp->priority = rand() % 10 + 1;temp->probTime = rand() % 10 + 1;temp->state = 0;temp->nextPCB = (i == (cnt-1))?0:new struct PCB;temp = temp->nextPCB;}int max = 0;//最高优先级struct PCB *curPCB;//正在执行的进程int countOfPro = cnt;//记录当前剩余进程数while(countOfPro != 0){for(struct PCB *p = head; p != 0; p = p->nextPCB) {if(p->state != 2 && p->priority > max){max = p->priority;curPCB = p;}}curPCB->priority--;curPCB->probTime--;if(curPCB->probTime <= 0){curPCB->state = 2;countOfPro--;}max = -99999;//打印运行后的进程属性内容printf("current proccess is %d ",curPCB->id);printf("priority is %d ", curPCB->priority);printf("rest time is %d\n", curPCB->probTime);}system("pause");return;}六、程序运行时的初值和运行结果七、实验体会此次实验模拟了系统进程调度,进一步学习了进程调度的机制,加深了对调度的理解。
操作系统实验报告作业调度

操作系统实验报告作业调度操作系统实验报告:作业调度引言作业调度是操作系统中的重要部分,它负责管理和调度系统中的各种作业,以最大化系统资源的利用率和提高作业的执行效率。
在本次实验中,我们将探讨作业调度的基本原理和实现方法,并通过实验验证其效果。
实验目的本次实验的主要目的是通过实际操作,了解作业调度的基本原理和实现方法,掌握作业调度的相关算法,并通过实验验证其有效性。
实验内容1. 实现作业调度的基本算法在本次实验中,我们将实现作业调度的基本算法,包括先来先服务(FCFS)、最短作业优先(SJF)、优先级调度(Priority Scheduling)和多级反馈队列调度(Multilevel Feedback Queue Scheduling)等。
通过编写代码,模拟这些算法的执行过程,并观察它们的效果。
2. 实验验证我们将设计一些测试用例,通过模拟作业的执行过程,分别使用不同的作业调度算法,并比较它们的执行效果。
通过实验验证,我们将得出不同算法的优劣势,并分析其适用场景。
实验结果经过实验验证,我们得出以下结论:1. 先来先服务(FCFS)算法适用于作业执行时间相对均匀的情况,但可能会导致平均等待时间较长。
2. 最短作业优先(SJF)算法能够最大程度地减少平均等待时间,但可能会出现作业饥饿现象。
3. 优先级调度(Priority Scheduling)算法能够根据作业的优先级进行调度,适用于有明确优先级需求的情况。
4. 多级反馈队列调度(Multilevel Feedback Queue Scheduling)算法能够根据作业的执行情况动态调整优先级,适用于各种类型的作业。
结论作业调度是操作系统中的重要组成部分,不同的作业调度算法适用于不同的场景。
通过本次实验,我们深入了解了作业调度的基本原理和实现方法,掌握了不同算法的优劣势,并通过实验验证了它们的有效性。
这将对我们进一步深入学习操作系统和提高系统性能有着重要的意义。
操作系统实验报告——调度算法

操作系统实验报告——调度算法1. 实验目的本实验旨在探究操作系统中常用的调度算法,通过编写代码模拟不同的调度算法,了解它们的特点和应用场景。
2. 实验环境本次实验使用的操作系统环境为Linux,并采用C语言进行编码。
3. 实验内容3.1 调度算法1:先来先服务(FCFS)FCFS调度算法是一种简单且常见的调度算法。
该算法按照进程到达的先后顺序进行调度。
在本实验中,我们使用C语言编写代码模拟FCFS算法的调度过程,并记录每个进程的等待时间、周转时间和响应时间。
3.2 调度算法2:最短作业优先(SJF)SJF调度算法是一种非抢占式的调度算法,根据进程的执行时间来选择下一个要执行的进程。
在本实验中,我们使用C语言编写代码模拟SJF算法的调度过程,并计算每个进程的等待时间、周转时间和响应时间。
3.3 调度算法3:轮转调度(Round Robin)Round Robin调度算法是一种经典的时间片轮转算法,每个进程在给定的时间片内依次执行一定数量的时间。
如果进程的执行时间超过时间片,进程将被暂时挂起,等待下一次轮转。
在本实验中,我们使用C语言编写代码模拟Round Robin算法的调度过程,并计算每个进程的等待时间、周转时间和响应时间。
4. 实验结果分析通过对不同调度算法的模拟实验结果进行分析,可以得出以下结论:- FCFS算法适用于任务到达的先后顺序不重要的场景,但对于执行时间较长的进程可能会导致下一个进程需要等待较久。
- SJF算法适用于任务的执行时间差异较大的场景,能够提高整体执行效率。
- Round Robin算法适用于时间片相对较小的情况,能够公平地为每个进程提供执行时间。
5. 实验总结本次实验通过模拟不同调度算法的实际执行过程,深入了解了各种调度算法的原理、特点和适用场景。
通过对实验结果的分析,我们可以更好地选择合适的调度算法来满足实际应用的需求。
在后续的学习中,我们将进一步探索更多操作系统相关的实验和算法。
操作系统实验-任务调度-报告

处理机调度-实时调度算法EDF和RMS报告人:一、实验目的深入理解处理机调度算法,了解硬实时概念,掌握周期性实时任务调度算法EDF(Earliest Deadline First)和RMS(Rate-Monotonic Scheduling)的可调度条件,并能在可调度的情况下给出具体调度结果。
二、实验内容在Linux环境中采用用户级线程模拟实现EDF和RMS两种实时调度算法。
给定一组实时任务,按照EDF算法和RMS算法分别判断是否可调度。
在可调度的情况下,创建一组用户级线程,分别代表各个实时任务,并按算法所确定的调度次序安排各个线程运行,运行时在终端上画出其Gantt图。
为避免图形绘制冲淡算法,Gantt图可用字符表示。
最早截止时间优先(EDF)算法根据任务的截止时间来确定任务的优先级。
截止时间愈早,优先级愈高。
该算法要求在系统中保持一个实时任务就绪队列,该队列按各任务截止时间的早晚排序。
具有最早截止时间的任务排在最前面,最先分配到处理机。
可用于抢占式调度和非抢占式调度,可用于周期性实时任务和非周期性实时任务。
实时调度 - RMS算法(1) 任务T i (P i, Ci, D i) 模型: 周期为P i,计算时间为Ci, 时限D i 为周期终点。
任务在周期起点释放, 高优先级任务可抢占低优先级任务的执行。
(2) 优先级分配方法: 静态固定分配。
优先级与周期成反比, 周期越短优先级越高。
(3) 可调度性分析: 如果任务集满足下式, 则该任务集可调度。
定理1:n个独立的周期任务可以被RMPA调度,如果U<=n(2^(1/n)-1)。
三、调度原则EDF为可抢先式调度算法,其调度条件为sum(Ci/Ti)≤1;RMS算法为不可抢先调度算法,其调度条件为sum(Ci/Ti)≤n(exp(ln(2)/n)-1)。
四、基本程序设计:实时任务用task数据结构描述,设计四个函数:select_proc()用于实现调度算法,被选中任务执行proc(),在没有可执行任务时执行idle(),主函数mian()初始化相关数据,创建实时任务并对任务进行调度。
作业调度实验报告

作业调度实验报告一、实验目的本次作业调度实验的主要目的是深入理解和掌握作业调度的基本原理和算法,通过实际编程和模拟实验,分析不同调度策略对系统性能的影响,从而为优化作业调度提供理论依据和实践经验。
二、实验环境本次实验在 Windows 10 操作系统下进行,使用 Python 语言作为主要的编程工具。
实验中所需的相关库包括`numpy`、`matplotlib` 等。
三、实验原理作业调度是操作系统中的一个重要组成部分,其主要任务是根据一定的调度策略,从就绪队列中选择作业并分配处理机资源,以实现系统资源的高效利用和作业的快速执行。
常见的作业调度算法包括先来先服务(FCFS)、短作业优先(SJF)、优先级调度、高响应比优先调度等。
先来先服务算法按照作业到达的先后顺序进行调度,先到达的作业先执行。
这种算法简单直观,但可能导致长作业长时间等待,影响系统的平均周转时间。
短作业优先算法优先调度执行时间短的作业,能够有效地减少作业的平均等待时间,但可能会导致长作业饥饿。
优先级调度根据作业的优先级来决定执行顺序,优先级高的作业先执行。
然而,确定合理的优先级是一个复杂的问题。
高响应比优先调度综合考虑了作业的等待时间和执行时间,通过计算响应比来决定作业的执行顺序,在一定程度上避免了长作业饥饿的问题。
四、实验内容(一)算法实现1、先来先服务算法```pythondef fcfs_scheduling(jobs):start_time = 0 len(jobs)finish_time = 0 len(jobs)waiting_time = 0 len(jobs)turnaround_time = 0 len(jobs)current_time = 0for i in range(len(jobs)):start_timei = current_timefinish_timei = current_time + jobsiturnaround_timei = finish_timei 0current_time = finish_timeireturn waiting_time, turnaround_time```2、短作业优先算法```pythondef sjf_scheduling(jobs):sorted_jobs = sorted(jobsitems(), key=lambda x: x1) start_time = 0 len(sorted_jobs)finish_time = 0 len(sorted_jobs)waiting_time = 0 len(sorted_jobs)turnaround_time = 0 len(sorted_jobs)current_time = 0for i in range(len(sorted_jobs)):start_timei = current_timefinish_timei = current_time + sorted_jobsi1turnaround_timei = finish_timei 0current_time = finish_timeireturn waiting_time, turnaround_time```3、优先级调度算法```pythondef priority_scheduling(jobs):sorted_jobs = sorted(jobsitems(), key=lambda x: x2, reverse=True) start_time = 0 len(sorted_jobs)finish_time = 0 len(sorted_jobs)waiting_time = 0 len(sorted_jobs)turnaround_time = 0 len(sorted_jobs)current_time = 0for i in range(len(sorted_jobs)):start_timei = current_timefinish_timei = current_time + sorted_jobsi1turnaround_timei = finish_timei 0current_time = finish_timeireturn waiting_time, turnaround_time```4、高响应比优先调度算法```pythondef hrrn_scheduling(jobs):response_ratio =for i in range(len(jobs)):waiting_time = 0for j in range(i):waiting_time += jobsjresponse_ratioappend((waiting_time + jobsi) / jobsi)sorted_jobs = job for _, job in sorted(zip(response_ratio, jobs),reverse=True)start_time = 0 len(sorted_jobs)finish_time = 0 len(sorted_jobs)waiting_time = 0 len(sorted_jobs)turnaround_time = 0 len(sorted_jobs)current_time = 0for i in range(len(sorted_jobs)):start_timei = current_timefinish_timei = current_time + sorted_jobsiwaiting_timei = current_timeturnaround_timei = finish_timei 0current_time = finish_timeireturn waiting_time, turnaround_time```(二)实验数据生成为了模拟不同的作业情况,生成了三组具有不同特点的作业数据,分别是:1、作业执行时间均匀分布的数据。
调度算法的实验报告

一、实验目的1. 理解操作系统调度算法的基本原理和概念。
2. 掌握几种常见调度算法的原理和实现方法。
3. 分析不同调度算法的性能特点,为实际应用提供参考。
二、实验内容本次实验主要涉及以下几种调度算法:先来先服务(FCFS)、最短作业优先(SJF)、优先级调度(Priority Scheduling)、最高响应比优先(HRRN)和时间片轮转(Round Robin)。
1. 先来先服务(FCFS)调度算法FCFS调度算法按照进程到达就绪队列的顺序进行调度,先到达的进程先执行。
该算法简单易实现,但可能导致长作业等待时间过长,从而降低系统吞吐量。
2. 最短作业优先(SJF)调度算法SJF调度算法优先选择执行时间最短的进程进行调度。
该算法可以最大程度地减少平均等待时间和平均周转时间,但可能导致长作业等待时间过长。
3. 优先级调度(Priority Scheduling)算法优先级调度算法为每个进程设置一个优先级,优先选择优先级高的进程进行调度。
该算法可以满足高优先级作业的需求,但可能导致低优先级作业长时间等待。
4. 最高响应比优先(HRRN)调度算法HRRN调度算法为每个进程设置一个响应比,优先选择响应比高的进程进行调度。
响应比是作业的等待时间与作业所需时间的比值。
该算法综合考虑了作业的等待时间和所需时间,是一种较为公平的调度算法。
5. 时间片轮转(Round Robin)调度算法时间片轮转调度算法将CPU时间划分为固定的时间片,按照进程到达就绪队列的顺序,每次只允许一个进程运行一个时间片。
如果进程在一个时间片内无法完成,则将其放入就绪队列的末尾,等待下一次调度。
该算法可以平衡各个进程的执行时间,但可能导致进程响应时间较长。
三、实验步骤1. 编写一个进程调度程序,实现上述五种调度算法。
2. 生成一个包含多个进程的作业队列,每个进程具有到达时间、所需运行时间和优先级等信息。
3. 分别采用五种调度算法对作业队列进行调度,并记录每个进程的执行情况。
作业调度实验报告

作业调度实验报告作业调度实验报告引言:作业调度是计算机操作系统中的一个重要概念,它涉及到如何合理地安排和管理计算机系统中的各个作业的执行顺序,以提高计算机系统的效率和资源利用率。
本实验旨在通过模拟不同的作业调度算法,探究它们在不同场景下的性能表现。
实验目的:1. 了解作业调度的基本概念和原理;2. 掌握作业调度算法的实现方法;3. 分析不同作业调度算法在不同场景下的优缺点。
实验过程:1. 实验环境的搭建在实验开始前,我们需要搭建一个适合进行作业调度实验的环境。
我们选择了一台配置较高的计算机,并安装了操作系统和相关的开发工具。
2. 实验数据的准备为了模拟真实的作业调度场景,我们需要准备一些作业数据。
这些数据包括作业的到达时间、执行时间、优先级等信息。
我们通过编写程序生成了一批随机的作业数据,并将其保存在文件中。
3. 实验算法的实现根据实验要求,我们实现了三种常见的作业调度算法:先来先服务(FCFS)、最短作业优先(SJF)和优先级调度算法(Priority Scheduling)。
我们使用C语言编写了相应的代码,并对其进行了测试和调试。
4. 实验结果的分析我们将不同作业调度算法在相同作业数据下的运行结果进行了比较和分析。
通过观察和统计,我们得到了各个算法的平均周转时间、平均等待时间等性能指标。
同时,我们还通过绘制图表的方式直观地展示了这些数据。
实验结果与讨论:1. 先来先服务算法(FCFS)先来先服务算法是最简单的作业调度算法之一,它按照作业到达的顺序依次执行。
在实验中,我们发现该算法对于短作业来说表现较好,但对于长作业来说会导致平均等待时间较长。
2. 最短作业优先算法(SJF)最短作业优先算法是一种非抢占式的调度算法,它优先执行执行时间最短的作业。
在实验中,我们发现该算法能够有效减少平均等待时间,但对于长作业来说可能会导致饥饿现象。
3. 优先级调度算法(Priority Scheduling)优先级调度算法根据作业的优先级来安排执行顺序。
操作系统实验报告作业调度

操作系统实验报告作业调度操作系统实验报告:作业调度引言:操作系统是计算机系统中最核心的软件之一,它负责管理计算机的资源,为用户提供良好的使用环境。
在操作系统中,作业调度是非常重要的一部分,它决定了计算机如何合理地分配和调度各个作业的执行顺序,以提高计算机的效率和性能。
本实验报告将介绍作业调度的概念、调度算法以及实验结果。
一、作业调度的概念作业调度是指根据一定的策略和算法,将就绪队列中的作业按照一定的顺序分配给处理器,使得计算机系统能够充分利用资源,提高系统的吞吐量和响应时间。
作业调度的目标是实现公平性、高效性和平衡性。
二、作业调度的算法1. 先来先服务(FCFS)调度算法FCFS调度算法是最简单的调度算法之一,它按照作业的到达顺序进行调度,先到达的作业先执行。
这种算法的优点是简单易实现,但是可能会导致长作业等待时间过长,造成资源浪费。
2. 最短作业优先(SJF)调度算法SJF调度算法是根据作业的执行时间来进行调度,执行时间短的作业先执行。
这种算法能够最大程度地减少平均等待时间,提高系统的响应速度,但是可能会导致长作业长时间等待。
3. 优先级调度算法优先级调度算法是根据作业的优先级来进行调度,优先级高的作业先执行。
这种算法可以根据不同的需求设置不同的优先级,但是可能会导致低优先级的作业长时间等待。
4. 时间片轮转调度算法时间片轮转调度算法是将处理器的执行时间划分为多个时间片,每个作业在一个时间片内执行,时间片用完后,将处理器分配给下一个作业。
这种算法可以实现公平性,但是可能会导致长作业等待时间过长。
三、实验结果与分析在本次实验中,我们使用了不同的作业调度算法,并对其进行了性能测试。
测试结果显示,FCFS算法在平均等待时间方面表现较差,而SJF算法和优先级调度算法在平均等待时间方面表现较好。
时间片轮转调度算法能够实现公平性,但是可能会导致长作业等待时间过长。
结论:作业调度是操作系统中的重要组成部分,合理的作业调度算法能够提高计算机系统的效率和性能。
操作系统之实验-作业调度

作业调度一、实习内容模拟批处理多道操作系统的作业调度。
二、实习目的每个用户请求计算机的一个计算任务叫做一个作业。
一个作业从初始数据到得到计算结果,要经过若干个步骤的相继执行。
例如,编辑、编译、运行等,其中每一个步骤称作一个作业步。
用户向系统提出作业加工的方式称作业控制方式,作业控制方式有两种:终端控制方式(又称直接控制方式或联机控制方式)和批处理控制方式(又称自动控制方式或脱机控制方式)。
在批处理控制方式下,用户采用系统提供的作业控制语言(JCL)写好作业说明书,说明作业加工的步骤。
操作员把一批作业组织成输入流,通过“预输入”手段使每个作业的信息(包括作业说明书、源程序、初始数据等)暂存在辅助存储器的“输入井”中。
批处理多道操作系统的作业管理有两个任务:作业调度和作业控制。
采用多道程序设计方法的操作系统,在系统中要经常保留多个运行的作业,以提高系统效率。
作业调度从系统已接纳的暂存在输入井中的一批作业中挑选出若干个可运行的作业,并为这些被选中的作业分配所需的系统资源。
对被选中运行的作业,必须按照它们各自的作业说明书规定的步骤进行控制。
本实习要求学生模拟作业调度的实现,了解作业调度在操作系统中的作用。
三、实习题目采用先来先服务算法和运行时间最短者优先算法模拟设计作业调度程序。
【提示】(1)作业调度程序负责从输入井选择若干个作业进入主存,为它们分配必要的资源,当它们能够被进程调度选中时,就可以占用处理器运行,作业调度选择一个作业的必要条件是系统中现有的尚未分配的资源可以满足该作业的资源需求。
但有进系统中现有的尚未分配的资源既可满足某个作业的要求也可以满足其它一些作业的要求,那么,作业调度必须按照一定的算法在这些作业中作出选择。
先来先服务算法是按照作业进入输入井的先后次序来挑选作业,先进入输入井的作业优先被挑选,当系统中现有的尚未分配的资源不能满足先进入输入井的作业时,那么顺序挑选后面的作业。
运行时间最短者优先算法总是按作业要求能满足的作业先进入主存执行。
操作系统实验报告作业调度

操作系统实验报告作业调度作业调度是操作系统中的一个重要组成部分,用于管理和分配计算机系统中的作业,确保系统可靠高效地运行。
作业调度算法的选择直接影响到系统的性能和资源利用率。
本实验通过对不同作业调度算法的理论分析和实际测试,探究它们的特点和优劣,最终找到适合特定场景的作业调度算法。
以下是本次实验的详细报告。
一、实验目的1.理解作业调度算法的原理和功能;2.掌握常用的作业调度算法;3.分析和比较不同作业调度算法的优缺点。
二、实验内容1. FIFO(First In First Out)作业调度算法;2. SJF(Shortest Job First)作业调度算法;3. RR(Round Robin)作业调度算法;4. HRN(Highest Response Ratio Next)作业调度算法。
三、实验过程1.FIFO作业调度算法FIFO算法是最简单的作业调度算法,按照作业提交的先后顺序进行调度。
首先将所有作业按照到达时间排序,然后按照顺序依次执行作业。
2.SJF作业调度算法SJF算法是根据作业的执行时间进行排序,优先执行执行时间最短的作业。
通过比较作业的执行时间,选择最短的作业进行执行。
3.RR作业调度算法RR算法是采用时间片轮转的方式进行调度。
每个作业分配一个时间片,当时间片用完后,将该作业移到队列的末尾继续执行。
时间片的长度可以根据需要进行调整。
4.HRN作业调度算法HRN算法是根据作业的响应比来确定调度顺序。
响应比由作业的等待时间和作业执行时间的比值来计算,响应比越大,优先级越高。
选择响应比最高的作业进行执行。
四、实验结果分析在本实验中,我们通过实际测试不同作业调度算法的性能来进行评估。
测试使用了一组模拟作业集,包括不同的作业执行时间和到达时间。
通过对比不同算法的实际表现1.FIFO算法的优点是简单易实现,但缺点是无法考虑作业的执行时间,因此可能导致平均等待时间较长。
2.SJF算法的优点是能够有效地减少平均等待时间,但缺点是对于长作业可能导致短作业长时间等待。
操作系统实验报告作业调度

操作系统实验报告:作业调度1. 引言作业调度是操作系统中的一个重要概念,它涉及到如何合理地安排计算机系统中的作业执行顺序,以最大程度地提高系统的效率和性能。
本文将介绍作业调度的基本概念和主要算法,以及在实验中的应用。
2. 作业调度的概念作业调度是指根据一定的策略和算法,按照一定的顺序从作业队列中选取作业,将其分配给可用资源来执行的过程。
作业调度的目标是实现公平、高效的任务分配,以提高系统的整体性能。
3. 作业调度算法3.1 先来先服务(FCFS)先来先服务是最简单的作业调度算法,即按照作业提交的顺序来执行。
当一份作业到达系统后,它将被放入作业队列的末尾。
一旦当前执行的作业完成,系统将选择队列中的下一个作业来执行。
3.2 短作业优先(SJF)短作业优先算法是根据作业的执行时间来进行调度,执行时间越短的作业优先级越高。
当一个作业进入系统时,系统会检查队列中的所有作业,并选择执行时间最短的作业来执行。
3.3 优先级调度优先级调度算法是根据作业的优先级来进行调度,优先级越高的作业优先级越高。
每个作业都会被分配一个优先级值,系统会按照优先级从高到低的顺序来执行作业。
3.4 时间片轮转调度时间片轮转调度算法将作业分为多个时间片,每个时间片的执行时间相等。
当一个作业进入系统时,系统会分配给它一个时间片,如果在时间片内作业没有完成,则将其放回队列的末尾,并执行下一个作业。
4. 实验中的应用在操作系统实验中,作业调度是一个重要的实验内容。
通过实验,我们可以深入了解不同调度算法的特点和适用场景。
实验中,我们可以使用模拟器来模拟作业调度的过程。
我们可以创建一个作业队列,然后使用不同的调度算法来执行这些作业,并记录它们的执行时间和系统的吞吐量。
通过实验,我们可以比较不同算法在不同场景下的表现,选择最适合当前系统的作业调度算法。
5. 结论作业调度是一个重要的操作系统概念,它决定了系统的性能和效率。
在本文中,我们介绍了作业调度的基本概念和常用算法,并讨论了在实验中的应用。
作业调度系统实验报告

一、实验目的1. 理解作业调度系统的基本原理和流程。
2. 掌握作业调度算法的设计与实现。
3. 评估不同作业调度算法的性能。
二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.73. 开发工具:PyCharm三、实验内容1. 作业调度系统概述2. 作业调度算法设计3. 作业调度系统实现4. 性能评估与分析四、实验步骤1. 作业调度系统概述(1)作业调度系统定义:作业调度系统是计算机系统中负责将作业分配到各个处理器(CPU)进行执行的部分。
(2)作业调度系统功能:作业调度系统负责接收作业、分析作业、选择作业执行、监控作业执行、处理作业异常等。
2. 作业调度算法设计(1)先来先服务(FCFS)算法:按照作业提交的顺序进行调度。
(2)短作业优先(SJF)算法:优先调度预计运行时间最短的作业。
(3)最高响应比优先(HRRN)算法:综合考虑作业的等待时间和估计运行时间,优先调度响应比最高的作业。
(4)轮转调度(RR)算法:将作业分配到各个处理器进行执行,每个处理器分配固定的时间片,时间片结束后进行抢占调度。
3. 作业调度系统实现(1)创建作业类:定义作业的属性,如作业ID、预计运行时间、实际运行时间等。
(2)创建调度器类:实现作业调度算法,包括作业接收、分析、选择、监控和异常处理等功能。
(3)创建处理器类:模拟CPU执行作业,记录作业执行时间。
(4)创建模拟环境:模拟多个作业提交到系统中,调度器根据算法进行调度,处理器执行作业。
4. 性能评估与分析(1)性能指标:平均等待时间、平均周转时间、吞吐量等。
(2)评估方法:通过模拟不同作业调度算法在相同作业集合下的性能,对比分析其优缺点。
(3)结果分析:根据实验结果,分析不同作业调度算法在处理不同作业集合时的性能表现。
五、实验结果与分析1. FCFS算法(1)平均等待时间:20ms(2)平均周转时间:25ms(3)吞吐量:0.82. SJF算法(1)平均等待时间:15ms(2)平均周转时间:20ms(3)吞吐量:0.93. HRRN算法(1)平均等待时间:18ms(2)平均周转时间:23ms(3)吞吐量:0.854. RR算法(1)平均等待时间:17ms(2)平均周转时间:22ms(3)吞吐量:0.86根据实验结果,SJF算法在处理短作业集合时具有较好的性能,平均等待时间和周转时间较短;而FCFS算法在处理长作业集合时性能较好,平均等待时间和周转时间较长。
作业调度实验报告

作业调度实验报告1. 实验目的通过本次实验,使学生了解作业调度算法的基本原理和实现方法,掌握作业调度的实际应用,提高计算机系统的作业吞吐量和系统效率。
2. 实验环境•操作系统:Linux•编程语言:Python•实验工具:CPU模拟器3. 实验原理作业调度是操作系统中的一个重要环节,主要负责将用户提交的作业按照一定的策略分配到CPU上执行。
作业调度的主要目标是提高CPU的利用率,缩短作业的平均等待时间,提高系统的吞吐量。
常用的作业调度算法有先来先服务(FCFS)、短作业优先(SJF)、最短剩余时间优先(SRT)等。
4. 实验内容本次实验主要分为两个部分:一是实现作业调度算法,二是对不同算法进行性能分析。
4.1 作业调度算法实现以先来先服务(FCFS)算法为例,实现作业调度如下:```pythonclass Job:def __init__(self, job_id, arrival_time, execute_time):self.job_id = job_idself.arrival_time = arrival_timeself.execute_time = execute_timeclass JobScheduler:def __init__(self):self.jobs = []def add_job(self, job):self.jobs.append(job)def schedule(self):start_time = 0finish_time = 0for job in self.jobs:if job.arrival_time >= start_time:start_time = job.arrival_timefinish_time = start_time + job.execute_timeprint(f"Job {job.job_id} arrives at {start_time} and finishes a t {finish_time}")start_time = finish_timeif name== “main”:scheduler = JobScheduler()scheduler.add_job(Job(1, 0, 5))scheduler.add_job(Job(2, 1, 3))scheduler.add_job(Job(3, 3, 8))scheduler.schedule()4.2 性能分析通过对不同作业调度算法的模拟运行,分析其性能指标,如平均等待时间、平均响应时间、吞吐量等。
操作系统实验报告批处理系统的作业调度

操作系统实验报告批处理系统的作业调度实验一批处理系统的作业调度一(实验目的(1)加深对作业概念的理解。
(2)深入了解批处理系统如何组织作业、管理作业和调度作业。
二(实验内容编写程序完成批处理系统的作业调度,要求采用响应比优先调度算法。
三(实验原理最高响应比优先法(HRRN)是对FCFS方式和SJF 方式的一种综合平衡。
HRRN调度策略同时考虑每个作业的等待时间长短和估计需要的执行时间长短,从中选出响应比最高的作业投入执行。
响应比R定义如下: R=(W+T)/T=1+W/T其中T为该作业估计需要的执行时间,W为作业在后备状态队列中的等待时间。
每当要进行作业调度时,系统计算每个作业的响应比,选择其中R最大者投入执行。
这样,即使是长作业,随着它等待时间的增加,W/T也就随着增加,也就有机会获得调度执行。
这种算法是介于FCFS和SJF 之间的一种折中算法。
由于长作业也有机会投入运行,在同一时间内处理的作业数显然要少于SJF 法,从而采用HRRN 方式时其吞吐量将小于采用SJF 法时的吞吐量。
另外,由于每次调度前要计算响应比,系统开销也要相应增加。
四(实验部分源程序实验中,作业控制块及队列的数据结构定义如下:struct task {string name; /*作业号*/int arrTime; /* 作业到达时间*/int serTime; /*作业要求服务时间*/int waiTime; /*等待时间*/int begTime; /*开始运行时间*/int finTime; /*结束运行时间*/int turTime; /*周转时间*/int wTuTime; /*带权周转时间*/int priority;/*优先权*/int finish;/*是否已经完成*/}JCB[10];存放作业控制块的区域:#define n 10JCB jobtable[10];int jobcount;将作业控制块组织成一个队列,实验中采用静态链表的方式模拟作业的后备队列,作业队列头指针定义为:int *head; 主程序为:#include<dos.h>#include<time.h>#include<stdlib.h> #include<stdio.h> #include<conio.h>#include<string.h> typedef char string[10]; /* //定义string为含有10个字符元素的字符数组类型*/struct task {string name; /*作业号*/int arrTime; /* 作业到达时间*/int serTime; /*作业要求服务时间*/int waiTime; /*等待时间*/int begTime; /*开始运行时间*/int finTime; /*结束运行时间*/int turTime; /*周转时间*/int wTuTime; /*带权周转时间*/int priority;/*优先权*/int finish;/*是否已经完成*/}JCB[10];int num; void input(){int i;system("cls");printf("\n请输入作业数量: "); scanf("%d", &num);for(i=0;i<num;i++){printf("\n请输入作业 NO.%d:\n",i); printf(" 作业名称: ");scanf("%s",JCB[i].name);printf(" 到达时间: ");scanf("%d",&JCB[i].arrTime);printf(" 服务时间: ");scanf("%d",&JCB[i].serTime);JCB[i].priority = 0;JCB[i].finish =0;}}int HRN(int pre){int current=1,i,j;/* 优先权 =(等待时间+服务时间)/服务时间*/for(i=0; i<num; i++){JCB[i].waiTime=JCB[pre].finTime-JCB[i].arrTime; /*等待时间 =上一个作业的完成时间-到达时间*/JCB[i].priority=(JCB[i].waiTime+JCB[i].serTime)/JCB[i].serTime;}for(i=0; i<num; i++){if(!JCB[i].finish){current=i; /*找到第一个还没完成的作业*/break;}}for( j=i; j<num; j++) /*和后面的作业比较*/{if( !JCB[j].finish) /* 还没完成(运行)*/{if(JCB[current].arrTime<=JCB[pre].finTime) /*如果作业在上一个作业完成之前到达*/{if(JCB[j].arrTime<=JCB[pre].finTime&&JCB[j].priority>JCB[current].pr iority )current=j;/* 找出到达时间在上一个作业完成之前,优先权高的作业*/ }else /* 如果作业是在上一个作业完成之后到达*/{if(JCB[j].arrTime<JCB[current].arrTime)current=j; /* 找出比较早到达的一个*/if(JCB[j].arrTime==JCB[current].arrTime) /* 如果同时到达*/if(JCB[j].priority>JCB[current].priority)current=j; /*找出服务时间比较短的一个*/}}}return current;/*返回当前作业*/}void runing(int i, int times, int pre, int staTime, int endTime) {if(times==0){JCB[i].begTime=JCB[i].arrTime;JCB[i].finTime=JCB[i].begTime+JCB[i].serTime; JCB[i].turTime=JCB[i].serTime;JCB[i].wTuTime=1.0;staTime=JCB[i].begTime;}else{if(JCB[i].arrTime>JCB[pre].finTime)JCB[i].begTime=JCB[i].arrTime;elseJCB[i].begTime=JCB[pre].finTime;JCB[i].finTime=JCB[i].begTime+JCB[i].serTime; JCB[i].turTime=JCB[i].finTime-JCB[i].arrTime; JCB[i].wTuTime=JCB[i].turTime/JCB[i].serTime; }if(times==num-1)endTime=JCB[i].finTime;JCB[i].finish=1;}void print(int i,int times){if(times==0){printf(" 名称到达时间服务时间开始时间完成时间周转时间带权周转时间\n");}printf("%9s%9d%9d%9d%9d%9d%9d\n",JCB[i].name,JCB[i].arrTime,JCB[i].serTime,JCB[i].begTime,JCB[i].finTime,JCB[i].turTime,JCB[i].wTuTime);}void check( ){int i;int staTime, endTime, sumTurTime=0.0, sumWTuTime=0.0, aveTurTime, aveWTuTime;int current=0, times=0, pre=0;JCB[pre].finTime=0;for(i=0; i<num; i++){JCB[i].finish=0;}staTime, endTime,sumTurTime=0.0, sumWTuTime=0.0, aveTurTime, aveWTuTime;current=0; times=0; pre=0;JCB[pre].finTime=0;printf("-------------------------------------------------------------------------\n");for(i=0; i<num; i++){JCB[i].finish=0;}staTime, endTime,sumTurTime=0.0, sumWTuTime=0.0, aveTurTime, aveWTuTime;current=0; times=0; pre=0;JCB[pre].finTime=0;printf("\n-- HRRN -----------------------------------------------------------------\n");for(times=0; times<num; times++){current=HRN(pre);runing(current, times, pre, staTime, endTime);print(current, times);pre=current;}for(i=0; i<num; i++){sumTurTime+=JCB[i].turTime;sumWTuTime+=JCB[i].wTuTime;}aveTurTime=sumTurTime/num;aveWTuTime=sumWTuTime/num;printf("(计与平均值) %9d%9d%9d%9d\n",NULL,sumTurTime,aveTurTime,aveWTuTime);printf("-------------------------------------------------------------------------\n");}void main(){char again;do {system("cls"); /*清屏*/printf("please input 4 groups of datas:\n");input();check();printf("Continue...(Y/N): ");do{again = getch();}while(again!='Y' && again!='y' && again!='N' && again!='n');}while(again=='Y' || again=='y'); }五(实验结果与体会从运行结果得到调度序列结果为:X1,X2,X31到达时间最早,服务时间也最短,其响应比最高; XX2到达时间为22,但X1早到达,所以开始时间为22,服务时间为12,所以响应比X1小;X3到达时间最迟,其响应比最小,所以在最后。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
#define NULL 0
int n;
float T1=0,T2=0;
int times=0;
struct jcb//作业控制块
{
char name[10]; //作业名
int reachtime; //作业到达时间
3、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间,以及这组作业的平均周转时间及带权平均周转时间。
3)流程图:
二.最短作业优先算法
三.高响应比算法
图一.先来先服务流程图
4)源程序:
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
{
if(m==3) //显示高响应比算法调度作业后的运行情况
{
printf("\n作业%s正在运行,估计其运行情况:\n",q->name);
printf("开始运行时刻:%d\n",q->starttime);
printf("完成时刻:%d\n",q->finishtime);
printf("周转时间:%f\n",q->cycletime);
struct jcb *next; //结构体指针
}*ready=NULL,*p,*q;
typedef struct jcb JCB;
void inize()//初始化界面
{
printf("\n\n\t\t*********************************************\t\t\n");
times+=p->needtime;
p->state='F';
printf("\n%s has been finished!\npress any key to continue...\n",p->name);
free(p); //释放运行后的作业
int starttime; //作业开始时间
int needtime; //作业需要运行的时间
float super; //作业的响应比
int finishtime; //作业完成时间
float cycletime; //作业时间
char state; //作业状态
printf("\t\t\t\t实验二 作业调度\n");
printf("\t\t*********************************************\t\t\n");
printf("\n\n\n\t\t\t\t\t计算机学院软件四班\n");
printf("\t\t\t\t\t蓝小花\n");
printf("完成时刻:%d\n",q->finishtime);
printf("周转时间:%f\n",q->cycletime);
printf("带权周转时间:%f\n",q->cltime);
getch();
}
}
void running(JCB *p,int m)//运行作业
{
if(p==ready) //先将要运行的作业从队列中分离出来
printf("\t\t\t\t\t3204007102\n");
printf("\t\t\t\t\t完成日期:2006年11月17号");
printf("\n\n\n\t\t请输入任意键进入演示过程\n");
getch();
}
void inital()//建立作业控制块队列,先将其排成先来先服务的模式队列
printf("带权周转时间:%f\n",q->cltime);
printf("相应比:%f\n",q->super);
getch();
}
else // 显示先来先服务,最短作业优先算法调度后作业的运行情况
{
printf("\n作业%s正在运行,估计其运行情况:\n",q->name);
printf("开始运行时刻:%d\n",q->starttime);
printf("\n输入作业要运行的时间:");
scanf("%d",&p->needtime);
p->state='W';
p->next=NULL;
if(ready==NULL) ready=q=p;
else{
q->next=p;
q=p;
}
}
}
void disp(JCB* q,int m)//显示作业运行后的周转时间及带权周转时间等
{
ready=p->next;
p->next=NULL;
}
else
{
q=ready;
while(q->next!=p) q=q->next;
q->next=p->next;
}
p->starttime=times; //计算作业运行后的完成时间,周转时间等等
p->state='R';
p->finishtime=p->starttime+p->needtime;
操作系统作业调度实验报告
执行程序: zuoye.exe
2)实验分析:
1、由于在单道批处理系统中,作业一投入运行,它就占有计算机的一切资源直到作业完成为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所占用的 CPU时限等因素。
2、每个作业由一个作业控制块JCB表示,JCB可以包含如下信息:作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。每个作业的最初状态总是等待W。
{
int i;
printf("\n输入作业数:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
p=getpch(JCB);
printf("\n输入作业名:");
scanf("%s",p->name);
getch();
p->reachtime=i;
printf("作业默认到达时间:%d",i);
p->cycletime=(float)(p->finishtime-p->reachtime);
p->cltime=(float)(p->cycletime/p->needtime);
T1+=p->cycletime;
T2+=p->cltime;
disp(p,m); //调用disp()函数,显示作业运行情况