实验四 作业调度

合集下载

作业调度_实验报告

作业调度_实验报告

实验名称作业调度实验内容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) 周转时间短。

通常把周转时间的长短作为评价批处理系统的性能、选择作业调度方式与算法的重要准则之一。

所谓周转时间,是指从作业被提交给系统开始,到作业完成为止的这段时间间隔(称为作业周转时间)。

算法分析与设计-实验四 作业调度问题-实验报告

算法分析与设计-实验四 作业调度问题-实验报告

南阳理工学院算法分析与设计实验报告册开课学院:计算机与软件学院实验项目:实验4:贪心法(作业调度问题)实验时间:第10周周3(3,4)节实验地点: 15#515指导教师:学生姓名:学生学号:专业班级:2020-2021学年第1学期一、实验目的1.了解贪心算法思想及基本原理2.掌握使用贪心算法求解问题的一般特征3.能够针对实际问题,能够正确选择贪心策略4.能够针对选择的贪心策略,证明算法的正确性5.能够根据贪心策略,正确编码6.能够正确分析算法的时间复杂度和空间复杂度二、实验平台1.JDK1.82.IDEA三、实验内容设有n个独立的作业{1, 2, …,n},由m台相同的机器{M1, M2, …,Mm}进行加工处理,作业i所需的处理时间为ti (1≤i≤n),每个作业均可在任何一台机器上加工处理,但不可间断、拆分。

多机调度问题要求给出一种作业调度方案,使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。

提示:贪心法求解多机调度问题的贪心策略是最长处理时间作业优先,即把处理时间最长的作业分配给最先空闲的机器,这样可以保证处理时间长的作业优先处理,从而在整体上获得尽可能短的处理时间。

按照最长处理时间作业优先的贪心策略,当m≥n时,只要将机器i的[0, ti)时间区间分配给作业i即可;当m<n时,首先将n 个作业依其所需的处理时间从大到小排序,然后依此顺序将作业分配给空闲的处理机。

四、算法设计1.问题分析设有n个独立的作业{1, 2, …, n}, 由m台相同的机器进行加工处理. 作业i所需时间为t i. 约定:任何作业可以在任何一台机器上加工处理, 但未完工前不允许中断处理,任何作业不能拆分成更小的子作业。

要求给出一种作业调度方案,使所给的n 个作业在尽可能短的时间内由m台机器加工处理完成。

多机调度问题是一个NP完全问题,到目前为止还没有完全有效的解法。

对于这类问题,用贪心选择策略有时可以设计出一个比较好的近似算法。

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

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

作业调度一、实验目的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),'响应比高者优先算法')。

作业调度

作业调度

实习九 作业调度一、实习内容模拟批处理多道操作系统的作业调度。

二、实习目的每个用户请求计算机计算的一个计算任务叫做一个作业。

一个作业从输入初始数据到得到计算结果,要经过若干个步骤的相继执行。

例如,编辑、编译、运行等,其中每一个步骤称作一个作业步。

用户向系统提出作业加工步骤的方式称作业控制方式,作业控制方式有两种:终端控制方式(又称直接控制方式或联机控制方式)和批处理控制方式(又称自动控制方式或脱机控制方式)。

在批处理控制方式下,用户采用系统提供的作业控制语言(JCL )写好作业说明书,说明作业加工的步骤。

操作员把一批作业组织成输入流,通过“预输入”手段使每个作业的信息(包括作业说明书、源程序、初始数据等)暂存在辅助存储器的“输入井”中。

批处理多道操作系统的作业管理有两个任务:作业调度和作业控制。

采用多道程序设计方法的操作系统,在系统中要经常保留多个运行的作业,以提高系统效率。

作业调度从系统已接纳的暂存在输入井中的一批作业中挑选出若干个可运行的作业,并为这些被选中的作业分配所需的系统资源。

对被选中运行的作业必须按照它们各自的作业说明书规定的步骤进行控制。

本实习要求学生模拟作业调度的实现,了解作业调度在操作系统中的作用。

三、实习题目采用先来先服务算法和运行时间最短者优先算法模拟设计作业调度程序。

[提示]:(1) 作业调度程序负责从输入井选择若干个作业进入主存,为它们分配必要的资源,当它们能够被进程调度选中时,就可占用处理器运行。

作业调度选择一个作业的必要条件是系统中现有的尚未分配的资源可满足该作业的资源要求。

但有时系统中现有的尚未分配的资源既可满足某个作业的要求也可满足其它一些作业的要求,那么,作业调度必须按一定的算法在这些作业中作出选择。

先来先服务算法是按照作业进入输入井的先后次序来挑选作业,先进入输入井的作业优先被挑选,当系统中现有的尚未分配的资源不能满足先进入输入井的作业时,那么顺序挑选后面的作业。

作业调度算法(先来先服务算法,短作业算法)

作业调度算法(先来先服务算法,短作业算法)

题目:作业调度算法班级:网络工程姓名:朱锦涛学号:E一、实验目的用代码实现页面调度算法,即先来先服务(FCFS)调度算法、短作业优先算法、高响应比优先调度算法。

通过代码的具体实现,加深对算法的核心的理解。

二、实验原理1.先来先服务(FCFS)调度算法FCFS是最简单的调度算法,该算法既可用于作业调度,也可用于进程调度。

当在作业调度中采用该算法时,系统将按照作业到达的先后次序来进行调度,或者说它是优先考虑在系统中等待时间最长的作业,而不管该作业所需执行的时间的长短,从后备作业队列中选择几个最先进入该队列的作业,将它们调入内存,为它们分配资源和创建进程。

然后把它放入就绪队列。

2.短作业优先算法SJF算法是以作业的长短来计算优先级,作业越短,其优先级越高。

作业的长短是以作业所要求的运行时间来衡量的。

SJF算法可以分别用于作业和进程调度。

在把短作业优先调度算法用于作业调度时,它将从外存的作业后备队列中选择若干个估计运行时间最短的作业,优先将它们调入内存。

3、高响应比优先调度算法高响应比优先调度算法则是既考虑了作业的等待时间,又考虑了作业的运行时间的算法,因此既照顾了短作业,又不致使长作业等待的时间过长,从而改善了处理机调度的性能。

如果我们引入一个动态优先级,即优先级是可以改变的令它随等待的时间的延长而增加,这将使长作业的优先级在等待期间不断地增加,等到足够的时间后,必然有机会获得处理机。

该优先级的变化规律可以描述为:优先权 = (等待时间 + 要求服务时间)/要求服务时间三、实验内容源程序:#include<>#include<>#include<>struct work{i nt id;i nt arrive_time;i nt work_time;i nt wait;f loat priority;typedef struct sjf_work{s truct work s_work; d = rand()%10;w[i].arrive_time = rand()%10;w[i].work_time = rand()%10+1;}f or(j=0;j<5;j++){printf("第%d个作业的编号是:%d\t",j+1,w[j].id);printf("第%d个作业到达时间:%d\t",j+1,w[j].arrive_time);printf("第%d个作业服务时间:%d\t",j+1,w[j].work_time);printf("\n");for(j=1;j<5;j++)for(k=0;k<5-j;k++){if(w[k].arrive_time > w[k+1].arrive_time) {temp = w[k];w[k] = w[k+1];w[k+1] = temp;}}printf("\n");w_finish_time[0] = w[0].arrive_time +w[0].work_time;for(j=0;j<5;j++){if(w_finish_time[j] < w[j+1].arrive_time){w_finish_time[j+1] = w[j+1].arrive_time + w[j+1].work_time;}elsew_finish_time[j+1] = w_finish_time[j] +w[j+1].work_time;}for(j=0;j<5;j++)w_rel_time[j] = w_finish_time[j] -w[j].arrive_time;for(j=0;j<5;j++){rel_time += w_rel_time[j];}for(j=0;j<5;j++){printf("第%d个系统执行的作业到达时间:%d ",j+1,w[j].arrive_time);printf("编号是:%d ",w[j].id);printf("服务时间是:%d ",w[j].work_time);printf("完成时间是:%d ",w_finish_time[j]);printf("周转时间是:%d ",w_rel_time[j]);printf("\n");}printf("平均周转时间:%f\n",rel_time/5); }void SJF(){i nt w_rel_time[10];i nt w_finish_time[10];f loat rel_time = 0;s rand(time(0));i nt i;i nt j = 0;P NODE pHead = (PNODE)malloc(sizeof(NODE));i f (NULL == pHead){printf("分配失败, 程序终止!\n");exit(-1);P NODE pTail = pHead;p Tail->pNext = NULL; 来先服务算法该算法严格按照各作业到达时间来为其分配进程和资源,实验的结果见截图,最后算出该算法五个作业的平均周转时间。

作业调度程序

作业调度程序

作业调度程序作业调度程序是操作系统中的一个重要组件,它负责将作业从提交状态转换为运行状态,并决定哪些作业在什么时候运行以及在哪个处理器上运行。

作业调度程序的目标是实现资源的有效利用,包括处理器、内存、磁盘等,以提高系统的整体性能。

一、作业调度程序的基本概念作业调度程序的主要任务是将作业放入等待队列,并根据一定的调度算法从等待队列中选取作业进行处理。

在操作系统中,作业是一个程序或一个程序的一个执行实例。

当用户提交一个作业时,操作系统会为该作业分配必要的资源,并将其放入等待队列中。

等待队列按照先进先出(FIFO)的原则对作业进行排序。

当一个处理器空闲时,作业调度程序会从等待队列中选取一个作业进行处理。

在选择作业时,需要考虑许多因素,如作业的优先级、作业的类型(批处理、交互式、实时等)、作业的性质(CPU密集型、I/O密集型)等。

二、常见的作业调度算法1.先来先服务(FCFS)算法:按照作业到达的顺序进行调度,优先级相同的情况下最先到达的作业将优先获得处理器。

这种算法简单易行,但无法充分利用系统资源。

2.最短作业优先(SJF)算法:优先调度预计运行时间最短的作业。

这种算法可以减少平均等待时间和平均周转时间,但可能造成短作业长时间等待。

3.优先级调度算法:为不同类型的作业分配不同的优先级,优先级高的作业将优先获得处理器。

这种算法可以实现资源的有效利用,但实现起来比较复杂。

4.轮转法(Round Robin):按照固定的时间片将处理器分配给等待队列中的作业,时间片用完后该作业被放到队尾重新排队。

这种算法可以实现资源的平均分配,但可能导致某些作业等待时间过长。

5.多级反馈队列算法:将等待队列分为多个级别,不同级别的队列采用不同的调度算法。

这种算法可以灵活地适应不同类型和不同性质的作业,但实现起来比较复杂。

三、作业调度程序的实现作业调度程序的实现需要依赖于操作系统的内核和处理器。

在内核中,需要实现等待队列的管理、进程状态的管理以及处理器上下文的保存和恢复等功能。

作业调度实验报告

作业调度实验报告

作业调度实验报告作业调度实验报告引言:作业调度是计算机操作系统中的一个重要概念,它涉及到如何合理地安排和管理计算机系统中的各个作业的执行顺序,以提高计算机系统的效率和资源利用率。

本实验旨在通过模拟不同的作业调度算法,探究它们在不同场景下的性能表现。

实验目的:1. 了解作业调度的基本概念和原理;2. 掌握作业调度算法的实现方法;3. 分析不同作业调度算法在不同场景下的优缺点。

实验过程:1. 实验环境的搭建在实验开始前,我们需要搭建一个适合进行作业调度实验的环境。

我们选择了一台配置较高的计算机,并安装了操作系统和相关的开发工具。

2. 实验数据的准备为了模拟真实的作业调度场景,我们需要准备一些作业数据。

这些数据包括作业的到达时间、执行时间、优先级等信息。

我们通过编写程序生成了一批随机的作业数据,并将其保存在文件中。

3. 实验算法的实现根据实验要求,我们实现了三种常见的作业调度算法:先来先服务(FCFS)、最短作业优先(SJF)和优先级调度算法(Priority Scheduling)。

我们使用C语言编写了相应的代码,并对其进行了测试和调试。

4. 实验结果的分析我们将不同作业调度算法在相同作业数据下的运行结果进行了比较和分析。

通过观察和统计,我们得到了各个算法的平均周转时间、平均等待时间等性能指标。

同时,我们还通过绘制图表的方式直观地展示了这些数据。

实验结果与讨论:1. 先来先服务算法(FCFS)先来先服务算法是最简单的作业调度算法之一,它按照作业到达的顺序依次执行。

在实验中,我们发现该算法对于短作业来说表现较好,但对于长作业来说会导致平均等待时间较长。

2. 最短作业优先算法(SJF)最短作业优先算法是一种非抢占式的调度算法,它优先执行执行时间最短的作业。

在实验中,我们发现该算法能够有效减少平均等待时间,但对于长作业来说可能会导致饥饿现象。

3. 优先级调度算法(Priority Scheduling)优先级调度算法根据作业的优先级来安排执行顺序。

操作系统实验--作业调度模拟

操作系统实验--作业调度模拟

一、实验目的和内容1、实验目的用高级语言编写和调试一个或多个作业调度的模拟程序,以加深对作业调度算法的理解。

2、实验内容编写并调试一个单道处理系统的作业等待模拟程序。

作业等待算法:分别采用先来先服务(FCFS),最短作业优先(SJF)、响应比高者优先(HRN)的调度算法。

对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间,以及这组作业的平均周转时间及带权平均周转时间,以比较各种算法的优缺点。

二、实验方案1、先来先服务算法原理:每次调度是从就绪队列中,选择一个最先进入就绪队列的进程,把处理器分配给该进程,使之得到执行。

该进程一旦占有了处理器,它就一直运行下去,直到该进程完成或因发生事件而阻塞,才退出处理器。

特点:利于长进程,而不利于短进程。

2、短作业优先服务算法原理:它是从就绪队列中选择一个估计运行时间最短的进程,将处理器分配给该进程,使之占有处理器并执行,直到该进程完成或因发生事件而阻塞,然后退出处理器,再重新调度。

3、最高响应比优先算法原理:它是从就绪队列中选择一个响应比最高的进程,让其获得处理器执行,直到该进程完成或因等待事件而退出处理器为止。

特点:既照顾了短进程,又考虑了进程到达的先后次序,也不会使长进程长期得不到服务,因此是一个比较全面考虑的算法,但每次进行调度时,都需要对各个进程计算响应比。

所以系统开销很大,比较复杂。

4、源代码#include<iostream.h>#include<stdlib.h>#include<stdio.h>typedef struct JCB //定义作业控制块JCB结构体{int ID; //作业标识数IDfloat requesttime; //作业运行所需要时间requesttimeint runtime; //作业实际运行时间runtimeint arrivetime; //作业到达时间arrivetimeint starttime; //作业开始时间starttimeint finishtime; //作业完成时间finishtimefloat zhuantime; //作业周转时间zhuantime}JCB;#define N 100 //宏定义JCB jcb[N]; //定义作业块数组int jcbnum; //定义作业块个数void init(); //初始化函数void FCFS(); //先来先服务算法void SJF(); //短作业优先算法void HRN(); //高响应比算法void init() //初始化作业调度块{int j=0;int req;while(j<=0||j>2000) //实现作业的输入{cout<<"请输入作业个数:(1--2000)";cin>>j;}jcbnum=j;for(j=0;j<jcbnum;j++) //实现作业的循环执行{cout<<"请输入第"<<j+1<<"个作业的完成所需时间,默认达到时间为"<<j<<endl;cin>>req;jcb[j].ID=j+1;jcb[j].requesttime=req;jcb[j].arrivetime=j;jcb[j].starttime=0;jcb[j].finishtime=0;jcb[j].zhuantime=0;}}void FCFS() //先到先服务算法的实现{int i;float a,b;b=a=0;cout<<"你选择用先到先服务算法进行作业调度,结果如下:"<<endl;cout<<"作业到达时间运行时间开始时间完成时间周转时间带权周转时间"<<endl;for(i=0;i<jcbnum;i++){int runtime=0;jcb[i].finishtime=jcb[i].starttime+jcb[i].requesttime;jcb[i].zhuantime=jcb[i].finishtime-jcb[i].arrivetime;cout<<" "<<jcb[i].ID<<"\t "<<jcb[i].arrivetime<<"\t "<<jcb[i].requesttime<<"\t "<<jcb[i].starttime<<"\t "<<jcb[i].finishtime<<"\t "<<jcb[i].zhuantime<<"\t "; /*输出作业的作业到达时间运行时间开始时间完成时间周转时间*/cout<<jcb[i].zhuantime/jcb[i].requesttime<<endl;jcb[i+1].starttime=jcb[i].finishtime;a+=jcb[i].zhuantime;b+=jcb[i].zhuantime/jcb[i].requesttime;}cout<<"平均周转时间:"<<a/jcbnum<<endl;cout<<"平均带权周转时间:"<<b/jcbnum<<endl;}void SJF()//短作业优先算法{int i,j,r,c,fin=0; float a,b;a=b=0;c=jcbnum;cout<<"你选择用短作业优先算法进行作业调度,结果如下"<<endl;cout<<"作业到达时间运行时间开始时间完成时间周转时间带权周转时间"<<endl;while(jcbnum>0){r=0;for(i=0;i<jcbnum;i++)if(jcb[r].requesttime>jcb[i].requesttime)r=i;jcb[r].starttime=fin;jcb[r].finishtime=fin+jcb[r].requesttime;jcb[r].zhuantime=jcb[r].finishtime-jcb[r].arrivetime;a+=jcb[r].zhuantime;b+=jcb[r].zhuantime/jcb[r].requesttime;cout<<" "<<jcb[r].ID<<"\t "<<jcb[r].arrivetime<<"\t "<<jcb[r].requesttime<<"\t "<<jcb[r].starttime<<"\t "<<jcb[r].finishtime<<"\t "<<jcb[r].zhuantime<<"\t ";cout<<jcb[r].zhuantime/jcb[r].requesttime<<endl;fin+=jcb[r].requesttime;for(j=r;j<jcbnum-1;j++){jcb[j].ID=jcb[j+1].ID;jcb[j].requesttime=jcb[j+1].requesttime;jcb[j].arrivetime=jcb[j+1].arrivetime;}jcbnum--;}cout<<"平均周转时间:"<<a/c<<endl;cout<<"平均带权周转时间:"<<b/c<<endl;cout<<endl;}void HRN()//高响应比算法{int i,j,r,c;float a,b;a=b=0;c=jcbnum;int waittime=0; //进程等待处理机所用时间cout<<"你选择高响应比优先算法进行作业调度,结果如下:"<<endl;cout<<"作业到达时间运行时间开始时间完成时间周转时间带权周转时间"<<endl;while(jcbnum>0){r=0;for(i=0;i<jcbnum;i++) //选择响应比最高的进程if((waittime+0.0)/jcb[r].requesttime>((waittime+0.0)/jcb[i].requesttime)) r=i;jcb[r].starttime=waittime;jcb[r].finishtime=waittime+jcb[r].requesttime;jcb[r].zhuantime=jcb[r].finishtime-jcb[r].arrivetime;a+=jcb[r].zhuantime;b+=jcb[r].zhuantime/jcb[r].requesttime;cout<<" "<<jcb[r].ID<<"\t "<<jcb[r].arrivetime<<"\t "<<jcb[r].requesttime<<"\t "<<jcb[r].starttime<<"\t "<<jcb[r].finishtime<<"\t "<<jcb[r].zhuantime<<"\t ";cout<<jcb[r].zhuantime/jcb[r].requesttime<<endl;waittime+=jcb[r].requesttime;for(j=r;j<jcbnum-1;j++){jcb[j].ID=jcb[j+1].ID;jcb[j].requesttime=jcb[j+1].requesttime;jcb[j].arrivetime=jcb[j+1].arrivetime;}jcbnum--;}cout<<endl;}//主函数void main(){ bool flog=1;int i=0;char ch;cout<<"********************************"<<endl;cout<<" | 1:先来先服务 |"<<endl;cout<<" | 2:短作业优先 |"<<endl;cout<<" | 3:最高响应比优先 |"<<endl;cout<<"********************************"<<endl;while(flog){init();a1: cout<<"请选择你要做的选项(1--3):";cin>>i;if(i>=0&&i<=3){switch(i){case 1:FCFS();break; //选择"1"的时候调用的是FCFS算法case 2:SJF();break; //选择"2"的时候调用的是SJF算法 case 3:HRN();break; //选择"3"的时候调用的是HRN算法}cout<<endl; }else{ cout<<"输入错误,请重新输入!"<<endl; goto a1;}cout<<"是否想要继续(N/Y)?:"; //是否继续执行cin>>ch;if(ch=='y'||ch=='Y') flog=1;else flog=0;}}三、实验数据、结果分析运行结果分别输入3个作业,选择不同的算法进行调度。

作业调度实验报告

作业调度实验报告

作业调度一、实验要求:编写一个作业调度程序,用一种调度算法,实现对一个给定的作业序列的调度。

并计算平均周转时间和加权周转时间。

二、设计思想:1.填写资源表,记录打印机和磁带机的分配情况;2. 填写内存自由区表,实现内存的分配和回收;3. 填写作业表JCB,记录作业所需的资源,和运行的过程;4.设立三个队列,后备队列,阻塞队列,运行队列。

5.算法流程初始化:将作业队列压入后备队列.置counttime指针为0(用来表示系统时间).循环:a)判断该时刻运行队列中有无作业到达终止时间.到达就退出队列.b)判断该时刻后备队列中有无作业要求进入运行队列.有者压入阻塞队列. 这里采用的是FCFS调度算法,所以先要将作业压入阻塞队列,等待先前进入阻塞队列的作业先运行.c)看阻塞队列是否有作业要运行,有就判断条件是否符合.资源是否足够.若运行,看运行队列中有多少作业在运行.用并行算法算出终止时间, 压入运行队列.d)counttime++,循环,直至所有队列为空.二、主要数据结构程序采用VC6MFC环境开发,(用到MFC的数组类)为了演示方便,本程序模拟1-5个作业,打印机数量为1台,磁带机为2台struct JCB{UINT ID; //作业号UINT RunTime;//实际运行时间UINT SetTime;//放入队列时间UINT TakeMem;//占用内存UINT MemSize;//内存大小float TakeTime;//要求计算时间UINT PrintNum;//申请的打印机数量UINT TapeNum;//申请的磁带机数量};struct RC{UINT Type; //资源类型是打印机还是磁带机?int User; //标识哪个作业使用了本资源int yPos; //用于画图状态图的参数COLORREF tagColor;//区别各个作业的颜色,用于图形显示};struct FBT{UINT size; //空闲块大小UINT addr; //空闲块首址};CArray<JCB,JCB>JCBList; //后备队列CArray<JCB,JCB>JCBWait; //阻塞队列CArray<JCB,JCB>JCBRun; //运行队列CArray<FBT,FBT>FBTList; //内存自由区表RC RCList[3]; //描述资源设备使用情况的结构数组UINT nTaper //可使用的磁带机数量UINT nPrinter //可使用的打印机数量三、主要算法与部分代码申请内存资源(成功返回内存块首址,失败返回0)int CTab1::get_block(UINT NeedSize){int i=0;int p;while (FBTList[i].size>0 && FBTList[i].size<NeedSize && i<FBTList.GetSize()) i++;if(i>=FBTList.GetSize()) return 0;p=FBTList[i].addr+FBTList[i].size-NeedSize;FBTList[i].size-=NeedSize;ShowMemList();return p; //返回分得的内存块首址}1.回收申请的内存块,并分三种情况合并空闲区bool CTab1::free_block(int addr,int size) //回收已分配的内存并修改自由区表{bool flag=false;int i=0;int nIndex;while (i<FBTList.GetSize()) //第一遍循环判断回收的块是否有下接区,有就合并,并向下执行。

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

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

操作系统实验报告作业调度作业调度是操作系统中的一个重要组成部分,用于管理和分配计算机系统中的作业,确保系统可靠高效地运行。

作业调度算法的选择直接影响到系统的性能和资源利用率。

本实验通过对不同作业调度算法的理论分析和实际测试,探究它们的特点和优劣,最终找到适合特定场景的作业调度算法。

以下是本次实验的详细报告。

一、实验目的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.熟悉作业调度过程中的各种参数和指标;4.进一步了解操作系统中的进程调度机制。

二、实验环境本次实验使用的操作系统环境为Windows平台。

三、实验内容1.实现一个简单的作业调度算法,根据作业的重要性和执行时间进行优先级排序;2.设计一个作业队列,模拟一系列作业的到达和执行过程;3.根据作业调度算法,将作业分配给CPU执行,并统计作业的等待时间、完成时间等指标;4.进行多次实验,比较不同调度算法之间的性能差异。

四、实验步骤1.首先,设计一个作业类,包括作业的名称、重要性、到达时间和执行时间等属性;2.定义一个作业队列,用于存储到达的作业,并按照到达时间进行排序;3.实现一个简单的作业调度算法,根据作业的重要性和执行时间进行优先级排序;4.设计一个CPU类,用于执行作业队列中的作业,并记录作业的等待时间、完成时间等指标;5.模拟一系列作业的到达和执行过程,将作业调度给CPU执行,并记录相关指标;6.分别使用不同的调度算法进行多次实验,比较各自的性能差异。

五、实验结果与分析通过多次实验,得到了不同调度算法下的作业等待时间、完成时间等指标,并进行了比较。

结果发现,在作业执行时间相同时,按照作业的重要性进行优先级排序的算法,能够使得较重要的作业尽早执行,因而整体的作业等待时间和完成时间较短。

而对于作业执行时间不一致的情况,采用短作业优先算法,可以使作业平均等待时间较短,但在一些较长的作业上可能会存在饥饿现象。

综合考虑作业的重要性和执行时间,采用带权重的优先级队列算法可以获得较好的调度效果。

六、实验总结通过本次实验,我深入了解了作业调度的概念、原理和实现方式。

通过对比不同调度算法的性能差异,对于实际的作业调度过程具有一定的指导意义。

此外,通过实验设计和代码实现,我也提高了编程和分析问题的能力。

总体而言,本次实验使我对操作系统中的作业调度有了更为深刻的理解,并提高了我的实践能力。

作业调度实验报告

作业调度实验报告

作业调度实验报告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 性能分析通过对不同作业调度算法的模拟运行,分析其性能指标,如平均等待时间、平均响应时间、吞吐量等。

作业调度实验报告

作业调度实验报告

作业调度实验报告一、实验目的本次作业调度实验的主要目的是深入理解和掌握作业调度的基本原理和算法,通过实际编程和模拟实验,分析不同调度策略对系统性能的影响,从而为优化作业调度提供理论依据和实践经验。

二、实验环境本次实验在 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)作业调度算法:分别采用先来先服务(FCFS),最短作业优先(SJF)、响应比高者优先(HRN)的调度算法。

I.先来先服务:就是每次调度都是从后备作业队列中,选择一个最先进入该队列的作业,将它调入内存,为它分配资源、创建进程,然后放入就绪队列,投入运行,一直运行到完成或发生某事件而阻塞后,才放弃处理。

II.最短作业优先:是从后备队列中选择一个估计运行时间最短的作业,将它调入内存运行并一直执行到完成,或发生某事件而被阻塞放弃处理时,再重新调度。

III.响应比高者优先:是通过计算出作业的响应比,按响应比高而进行调度的,其计算公式是:优先权=(等待时间+要求服务时间)/要求服务时间.(3)由于在单道批处理系统中,作业一投入运行,它就占有计算机的一切资源直到作业完成为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所占用的CPU时限等因素。

(4)每个作业由一个作业控制块JCB表示,JCB可以包含如下信息:作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。

作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。

每个作业的最初状态总是等待W。

(5)对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间,以及这组作业的平均周转时间及带权平均周转时间,并比较各种算法的优缺点。

三、实验主要仪器设备和材料硬件环境:IBM-PC或兼容机软件环境:C语言编程环境四、实验原理及设计方案调度也称dispatcher,这是内核的主要职责之一。

一个良好的任务调度算法应该主要体现在以下几个方面:1.公平:保证每个进程得到合理的CPU 时间;2.高效:使CPU 保持忙碌状态,即总是有进程在CPU 上运行;3.响应时间:使交互用户的响应时间尽可能短;4.周转时间:使批处理用户等待输出的时间尽可能短;5.吞吐量:使单位时间内处理的进程尽可能多;很显然在任何操作系统中这几个目标不可能同时达到所以不同的。

作业调度算法-实验报告

作业调度算法-实验报告

作业调度算法-实验报告作业调度算法模拟一、课题内容和要求常见的作业调度算法有先来先服务算法、最短作业优先算法、响应比优先调度算法。

(1) 参考操作系统教材理解这3种算法。

(2) 实现这3个算法。

(3) 已知若干作业的到达时间和服务时间,用实现的算法计算对该组作业进行调度的平均周转时间Ttime和平均带权周转时间WTtime。

(4) 作业的到达时间和服务时间可以存放在文本文件record.txt中。

(5) 设计简单的交互界面,演示所设计的功能。

(可以使用MFC进行界面的设计) (6)可根据自己能力,在完成以上基本要求后,对程序功能进行适当扩充。

二、需求分析模拟实现作业调度算法,包括:FCFS(先来先服务算法)、SJF(短作业优先算法)、HRN(最高响应比优先算法)、HPF(基于优先数调度算法)。

先来先服务算法:按照各个作业进入系统(输入井)的自然次序来调度算法。

短作业优先算法:优先调度并处理短作业。

所谓的“短作业”并不是指物理作业长度短,而是指作业的运行时间短。

最高响应比优先算法:优先调度并处理响应比最高的作业。

三、概要设计函数中一些类:Time类 int hour 小时 int minute 分钟 Job 类 Int ID 作业编号 Time enter 进入时间 int requesttime 估计运行时间 intpriority 优先数 Time start Time end int Ttime double WTtime 开始时间结束时间周转时间带权周转时间Schedule类 int size Job *job int *r Int Differ() void HRN() 作业数作业数组排序用数组求时间差最高响应比优先 schedule() void readFile() void FCFS() void SJF() 构造函数从文件读信息先来先服务短作业优先主要功能函数的流程图 1、 EDIT1 平均带权周转时间 2、先来先服务:结束 EDIT2 平均周转时间 EDIT4 平均周转时间 EDIT5 平均带权周转时间EDIT6 平均周转时间 EDIT7 平均带权周转时间 OnButton1() FCFS OnButton2() SJF 开始 readFile()给变量赋值 OnButton3() HRN 开始感谢您的阅读,祝您生活愉快。

作业调度系统实验报告

作业调度系统实验报告

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

实验四 作业调度一. 实验目的本实验要求用高级语言(C 语言实验环境)编写和调试多个作业调度执行的模拟程序,了解作业调度在操作系统中的作用,以加深对作业调度算法的理解二. 实验要求分别模拟先来先服务(FCFS ),最短作业优先(SJF )、响应比高者优先(HRN )的调度算法。

(1)先来先服务算法:按照作业提交给系统的先后顺序来挑选作业,先提交的先被挑选。

(2)最短作业优先算法:是以进入系统的作业所提出的“执行时间”为标准,总是优先选取执行时间最短的作业。

(3)响应比高者优先算法:是在每次调度前都要计算所有被选作业(在后备队列中)的响应比,然后选择响应比最高的作业执行。

三 .程序流程图:一.先来先服务算法二.最短作业优先算法三.高响应比算法四.源程序:#include <stdio.h>#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0int n;float T1=0,T2=0;int times=0;struct jcb //作业控制块{char name[10]; //作业名int reachtime; //作业到达时间int starttime; //作业开始时间int needtime; //作业需要运行的时间float super; //作业的响应比int finishtime; //作业完成时间float cycletime; //作业周转时间float cltime; //作业带权周转时间char state; //作业状态struct jcb *next; //结构体指针}*ready=NULL,*p,*q;typedef struct jcb JCB;void inize() //初始化界面{printf("\n\n\t\t*********************************************\t\t\n");printf("\t\t\t\t操作系统实验作业调度\n");printf("\t\t*********************************************\t\t\n");printf("\n\n\n\t\t请输入任意键进入演示过程\n");getch();}void inital() //建立作业控制块队列,先将其排成先来先服务的模式队列{int i;printf("\n输入作业数:");scanf("%d",&n);for(i=0;i<n;i++){p=getpch(JCB);printf("\n输入作业名:");scanf("%s",p->name);printf("\n输入作业到达时间:");scanf("%d",&p->reachtime);// p->reachtime=i;// printf("作业默认到达时间:%d",i);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) //显示作业运行后的周转时间及带权周转时间等{if(m==3) //显示高响应比算法调度作业后的运行情况{printf("\n作业%s正在运行,估计其运行情况:\n",q->name);printf("开始运行时刻:%d\n",q->starttime);printf("完成时刻:%d\n",q->finishtime);printf("周转时间:%f\n",q->cycletime);printf("带权周转时间:%f\n",q->cltime);printf("相应比:%f\n",q->super);}else // 显示先来先服务,最短作业优先算法调度后作业的运行情况{printf("\n作业%s正在运行,估计其运行情况:\n",q->name);printf("开始运行时刻:%d\n",q->starttime);printf("完成时刻:%d\n",q->finishtime);printf("周转时间:%f\n",q->cycletime);printf("带权周转时间:%f\n",q->cltime);}}void running(JCB *p,int m) //运行作业{if(p==ready) //先将要运行的作业从队列中分离出来{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;p->cycletime=(float)(p->finishtime-p->reachtime);p->cltime=(float)(p->cycletime/p->needtime);T1+=p->cycletime;T2+=p->cltime;disp(p,m); //调用disp()函数,显示作业运行情况times+=p->needtime;p->state='F';printf("\n%s has been finished!\npress any key to continue...\n",p->name);free(p); //释放运行后的作业getch();}void super() //计算队列中作业的高响应比{JCB *padv;padv=ready;do{if(padv->state=='W'&&padv->reachtime<=times)padv->super=(float)(times-padv->reachtime+padv->needtime)/padv->needtime; padv=padv->next;}while(padv!=NULL);}void final() //最后打印作业的平均周转时间,平均带权周转时间{float s,t;t=T1/n;s=T2/n;getch();printf("\n\n作业已经全部完成!");printf("\n%d个作业的平均周转时间是:%f",n,t);printf("\n%d个作业的平均带权周转时间是%f:\n\n\n",n,s); }void hrn(int m) //高响应比算法{JCB *min;int i,iden;system("cls");inital();for(i=0;i<n;i++){p=min=ready;iden=1;super();do{if(p->state=='W'&&p->reachtime<=times)if(iden){min=p;iden=0;}else if(p->super>min->super) min=p;p=p->next;}while(p!=NULL);if(iden){i--;times++;//printf("\ntime=%d:\tno JCB submib...wait...",time);if(times>1000){printf("\nruntime is too long...error...");getch();}}else{running(min,m); //调用running()函数}} //forfinal(); //调用final()函数}void sjf(int m) // 最短作业优先算法{JCB *min;int i,iden;system("cls");inital();for(i=0;i<n;i++){p=min=ready;iden=1;do{if(p->state=='W'&&p->reachtime<=times)if(iden){min=p;iden=0;}else if(p->needtime<min->needtime) min=p;p=p->next;}while(p!=NULL) ;if(iden) {i--; //printf("\ntime=%d:\tno JCB submib...wait...",time);times++;if(times>100){printf("\nruntime is too long...error");getch();} }else{running(min,m); //调用running()函数}} //forfinal(); //调用final()函数}void fcfs(int m) //先来先服务算法{int i,iden;system("cls");inital();for(i=0;i<n;i++){p=ready;iden=1;do{if(p->state=='W'&&p->reachtime<=times) iden=0;if(iden)p=p->next;}while(p!=NULL&&iden) ;if(iden){i--;printf("\n没有满足要求的进程,需等待");times++;if(times>100){printf("\n时间过长");getch();}}else{running(p,m); //调用running()函数}}final(); //调用final()函数}void mune(){int m;system("cls");printf("\n\n\t\t*********************************************\t\t\n"); printf("\t\t\t\t作业调度演示\n");printf("\t\t*********************************************\t\t\n");printf("\n\n\n\t\t\t1.先来先服务算法.");printf("\n\t\t\t2.最短作业优先算法.");printf("\n\t\t\t3.响应比高者优先算法");printf("\n\t\t\t0.退出程序.");printf("\n\n\t\t\t\t选择所要操作:");scanf("%d",&m);switch(m){case 1:fcfs(m);getch();// system("cls");// mune();break;case 2:sjf(m);getch();// system("cls");// mune();break;case 3:hrn(m);getch();// system("cls");// mune();break;case 0:system("cls");break;default:printf("选择错误,重新选择.");getch();system("cls");mune();}}void main() //主函数{inize();mune();}五.实验结果分析1.对于下表中的作业队列,模拟执行各个作业调度算法,并记录相应的运行过程及运行结果。

相关文档
最新文档