作业调度实验报告
作业调度_实验报告
实验名称作业调度实验内容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.分别使用不同的调度算法进行多次实验,比较各自的性能差异。
五、实验结果与分析通过多次实验,得到了不同调度算法下的作业等待时间、完成时间等指标,并进行了比较。
结果发现,在作业执行时间相同时,按照作业的重要性进行优先级排序的算法,能够使得较重要的作业尽早执行,因而整体的作业等待时间和完成时间较短。
而对于作业执行时间不一致的情况,采用短作业优先算法,可以使作业平均等待时间较短,但在一些较长的作业上可能会存在饥饿现象。
综合考虑作业的重要性和执行时间,采用带权重的优先级队列算法可以获得较好的调度效果。
六、实验总结通过本次实验,我深入了解了作业调度的概念、原理和实现方式。
通过对比不同调度算法的性能差异,对于实际的作业调度过程具有一定的指导意义。
此外,通过实验设计和代码实现,我也提高了编程和分析问题的能力。
总体而言,本次实验使我对操作系统中的作业调度有了更为深刻的理解,并提高了我的实践能力。
操作系统作业调度算法实验
操作系统作业调度算法实验
操作系统作业调度算法实验可以让你更深入地理解作业调度的概念和方法,以下是实验的基本步骤和内容:
一、实验目的
掌握作业调度的基本概念和算法原理。
理解不同作业调度算法的特点和优缺点。
通过实验验证作业调度算法的正确性和性能。
二、实验内容
实验准备:准备一台计算机或模拟器,安装操作系统,并准备好实验所需的作业。
实验步骤:
(1)编写作业描述文件,包括作业的名称、到达时间、所需资源等信息。
(2)实现先来先服务(FCFS)、最短作业优先(SJF)、最高响应比优先(HRN)等作业调度算法,并编写相应的调度程序。
(3)将作业按照一定的顺序输入到调度程序中,并记录每个作业的执行时间、等待时间等参数。
(4)根据记录的数据计算平均周转时间、平均带权周转时间等指标,分析不同调度算法的性能差异。
(5)根据实验结果,分析不同调度算法的优缺点,并给出改进建议。
实验报告:整理实验数据和结果,撰写实验报告,包括实验目的、实验内容、实验步骤、实验结果、分析和结论等部分。
三、实验注意事项
在实验过程中,要注意保证作业的公平性,避免某些作业一直得不到执行的情况发生。
在实验过程中,要注意观察和记录每个作业的执行时间和等待时间等参数,以便后续的分析和比较。
在实验过程中,要注意保证系统的稳定性和可靠性,避免出现意外情况导致实验结果不准确。
在实验过程中,要注意遵守实验室规定和操作规程,确保实验过程的安全和顺利进行。
操作系统实验报告作业调度
操作系统实验报告作业调度操作系统实验报告:作业调度引言作业调度是操作系统中的重要部分,它负责管理和调度系统中的各种作业,以最大化系统资源的利用率和提高作业的执行效率。
在本次实验中,我们将探讨作业调度的基本原理和实现方法,并通过实验验证其效果。
实验目的本次实验的主要目的是通过实际操作,了解作业调度的基本原理和实现方法,掌握作业调度的相关算法,并通过实验验证其有效性。
实验内容1. 实现作业调度的基本算法在本次实验中,我们将实现作业调度的基本算法,包括先来先服务(FCFS)、最短作业优先(SJF)、优先级调度(Priority Scheduling)和多级反馈队列调度(Multilevel Feedback Queue Scheduling)等。
通过编写代码,模拟这些算法的执行过程,并观察它们的效果。
2. 实验验证我们将设计一些测试用例,通过模拟作业的执行过程,分别使用不同的作业调度算法,并比较它们的执行效果。
通过实验验证,我们将得出不同算法的优劣势,并分析其适用场景。
实验结果经过实验验证,我们得出以下结论:1. 先来先服务(FCFS)算法适用于作业执行时间相对均匀的情况,但可能会导致平均等待时间较长。
2. 最短作业优先(SJF)算法能够最大程度地减少平均等待时间,但可能会出现作业饥饿现象。
3. 优先级调度(Priority Scheduling)算法能够根据作业的优先级进行调度,适用于有明确优先级需求的情况。
4. 多级反馈队列调度(Multilevel Feedback Queue Scheduling)算法能够根据作业的执行情况动态调整优先级,适用于各种类型的作业。
结论作业调度是操作系统中的重要组成部分,不同的作业调度算法适用于不同的场景。
通过本次实验,我们深入了解了作业调度的基本原理和实现方法,掌握了不同算法的优劣势,并通过实验验证了它们的有效性。
这将对我们进一步深入学习操作系统和提高系统性能有着重要的意义。
先来先服务调度和最短作业优先调度算法实验报告
先来先服务调度和最短作业优先调度算法实验报告实验报告一、实验目的本实验旨在通过编写代码实现先来先服务调度算法和最短作业优先调度算法,以深入理解和掌握这两种调度算法的原理和实现方法。
二、实验方法和原理1.先来先服务调度算法(FCFS)2.最短作业优先调度算法(SJF)最短作业优先调度算法是根据作业所需的运行时间进行调度的。
当一个作业到达并获得CPU后,系统会选择剩余运行时间最短的作业进行处理,这样可以最大化地提高系统的吞吐量。
三、实验过程与结果1.先来先服务调度算法的实现我们先定义一个作业类Job,其中包含作业名称、到达时间和运行时间等属性。
首先根据到达时间对作业队列进行排序,然后按照顺序执行作业,记录每个作业的开始时间、结束时间和周转时间等指标。
下面是先来先服务调度算法的代码实现部分:```pythonclass Job: = namedef fcfs_scheduler(jobs):for job in sorted_jobs:#创建作业队列jobs =Job("Job1", 0, 3),Job("Job2", 1, 4),Job("Job3", 2, 2),Job("Job4", 4, 1)#调度作业fcfs_scheduler(jobs)#输出结果for job in jobs:```运行以上代码,会得到作业的开始时间、结束时间和周转时间等信息。
2.最短作业优先调度算法的实现最短作业优先调度算法需要知道每个作业的运行时间,而这个信息在实际情况中是未知的。
因此,我们可以先按到达时间对作业队列进行排序,然后在每个时间片中选择剩余运行时间最短的作业进行执行。
下面是最短作业优先调度算法的代码实现部分:```pythondef sjf_scheduler(jobs):while True:if not remaining_jobs:break#创建作业队列jobs =Job("Job1", 0, 3),Job("Job2", 1, 4),Job("Job3", 2, 2),Job("Job4", 4, 1)#调度作业sjf_scheduler(jobs)#输出结果for job in jobs:```运行以上代码,会得到相应的作业调度结果。
作业调度实验报告
作业调度实验报告一、实验目的本次作业调度实验的主要目的是深入理解和掌握作业调度的基本原理和算法,通过实际编程和模拟实验,分析不同调度策略对系统性能的影响,从而为优化作业调度提供理论依据和实践经验。
二、实验环境本次实验在 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、作业执行时间均匀分布的数据。
作业调度实验报告
作业调度实验报告作业调度算法实验。
二、实验目标已知n个作业的进入时间和估计运行时间(以分钟计)(1)单道环境下,分别用先来先服务调度算法、短作业优先调度算法、响应比高者优先调度算法,求出批作业的平均周转时间和带权平均周转时间;在多道环境(如2道)下,求出这些作业的平均周转时间和带权平均周转时间(2)就同一批次作业,分别讨论这些算法的优劣;(3)衡量同一调度算法对不同作业流的性能。
三、实验环境要求1.PC机。
2.Windows环境。
3.CodeBlocks四、实验基本原理(1)先来先服务算法:按照作业提交给系统的先后顺序来挑选作业,先提交的先被挑选。
(2)最短作业优先算法:是以进入系统的作业所提出的“执行时间”为标准,总是优先选取执行时间最短的作业。
( 3)响应比高者优先算法:是在每次调度前都要计算所有被选作业(在后备队列中)的响应比,然后选择响应比最高的作业执行。
(4)两道批处理系统中最短作业优先调度算法:内存中可以进入两个作业,这两个作业按照最短作业优先调度算法调整作业执行的次序。
五、数据结构设计使用一维数组来保存多个作业Job job[20];,采用的是顺序存储。
使用queue<Jcb *> q保存调度队列里的作业指针。
struct Date//时间结构体{int hour;//时间的小时int minute;//时间的分钟};struct Jcb//作业结构体,用来描述作业{int no;//作业编号Date enter;//进入时间int operation;//估计运行时间Date start;//开始时间Date over;//结束时间int turnover;//周转时间double weighted;//带权周转时间int state=0;//标记改作业是否进入运行状态};六、流程图单道环境下算法流程图多道环境下的两道批处理系统中最短作业优先作业调度算法的流程图。
七、源代码#include<iostream> #include<stdio.h>#include<cstring>#include<algorithm> #include<queue> using namespace std;struct Date//时间结构体{int hour;//时间的小时int minute;//时间的分钟};struct Jcb//作业结构体,用来描述作业{int no;//作业编号Date enter;//进入时间int operation;//估计运行时间Date start;//开始时间Date over;//结束时间int turnover;//周转时间double weighted;//带权周转时间int state=0;//标记改作业是否进入运行状态};//函数声明void display(Jcb J[],int n);//输出void runing( queue<Jcb *> q,int n);//根据算法将就绪队列排好队后的单道作业的运行主体void fcfs( Jcb J[],int n);//先来先服务作业调度void sfc(Jcb J[],int n);//最短作业优先作业调度void hrfc(Jcb J[],int n);//最高响应比作业调度void text(void (*dispatch)(Jcb J[], int n),Jcb J[],int n,Jcb J1[],int n1, Jcb J2[],int n2);//测试单道环境,不同批次作业,相同算法void mulfc(Jcb J[],int n);//两道环境,内存中可以用两个作业,内存中的这两个作业按照作业长短调整作业执行的次序。
作业调度实验报告
作业调度实验报告作业调度实验报告引言:作业调度是计算机操作系统中的一个重要概念,它涉及到如何合理地安排和管理计算机系统中的各个作业的执行顺序,以提高计算机系统的效率和资源利用率。
本实验旨在通过模拟不同的作业调度算法,探究它们在不同场景下的性能表现。
实验目的:1. 了解作业调度的基本概念和原理;2. 掌握作业调度算法的实现方法;3. 分析不同作业调度算法在不同场景下的优缺点。
实验过程:1. 实验环境的搭建在实验开始前,我们需要搭建一个适合进行作业调度实验的环境。
我们选择了一台配置较高的计算机,并安装了操作系统和相关的开发工具。
2. 实验数据的准备为了模拟真实的作业调度场景,我们需要准备一些作业数据。
这些数据包括作业的到达时间、执行时间、优先级等信息。
我们通过编写程序生成了一批随机的作业数据,并将其保存在文件中。
3. 实验算法的实现根据实验要求,我们实现了三种常见的作业调度算法:先来先服务(FCFS)、最短作业优先(SJF)和优先级调度算法(Priority Scheduling)。
我们使用C语言编写了相应的代码,并对其进行了测试和调试。
4. 实验结果的分析我们将不同作业调度算法在相同作业数据下的运行结果进行了比较和分析。
通过观察和统计,我们得到了各个算法的平均周转时间、平均等待时间等性能指标。
同时,我们还通过绘制图表的方式直观地展示了这些数据。
实验结果与讨论:1. 先来先服务算法(FCFS)先来先服务算法是最简单的作业调度算法之一,它按照作业到达的顺序依次执行。
在实验中,我们发现该算法对于短作业来说表现较好,但对于长作业来说会导致平均等待时间较长。
2. 最短作业优先算法(SJF)最短作业优先算法是一种非抢占式的调度算法,它优先执行执行时间最短的作业。
在实验中,我们发现该算法能够有效减少平均等待时间,但对于长作业来说可能会导致饥饿现象。
3. 优先级调度算法(Priority Scheduling)优先级调度算法根据作业的优先级来安排执行顺序。
调度实习报告四篇_1
调度实习报告四篇调度实习报告篇1一. 实习动机:经过对物流专业的学习,对物流的定义,基本功能,各个作业流程有了一定的理论基础,通过实习将这些理论与实际的操作相结合,在实践中提高运用知识的能力.二. 实习目的:了解第三方物流服务的特点、主要设备和作业流程,对其进行分析,并结合所学的理论提出改进意见。
三. 实习单位简介:1.公司介绍:中外运公司是中国物流业异军突起的新兴物流企业,具备国内道路运输许可资质。
其业务涵盖国内零担运输、仓储包装、城际快运、整车包车、代收货款等业务,可为客户提供全方位的物流服务。
公司以建立中国最具实力的专业市场物流企业为经营目标、以人才经营为核心、以品牌经营为导向,专注于做好一件事——为专业市场物流提速。
公司斥巨资自建网络、自购车辆、组建资历深厚的经营管理班底,致力于为客户提供准时、安全、诚信、专业的综合性物流服务。
目前在天津已经形成以北京为中心辐射整个华北网络布局,中国外运正在以良好的态势快速向前发展……2.公司设施:1). 车辆,公司拥有500多辆车.同时拥有几个车队,可调动较近车辆。
2).公司仓库:公司拥有大型的运作场地,仓储和运作一体。
空间高度为3米。
总设计面积80000平方米。
该类型的运作场地的优点是防汛,防潮性能良好,库外周转场地大,特别适合于中国外运这种经营多种业务的物流公司进行转趟运作。
3).信息服务系统:我们公司拥有先进的管理系统软件。
操作方便,简单。
能对客户的需要提供最大的帮助,更能及时准确的反映出公司的一切运转情况。
为公司的发展提供了良好的服务环境!确保了公司各环节的正常运行! 四.实习内容:实习的地方是天津市大港区。
职位是业务调度员,将物流操作过程的各个环节进行衔接处理、调度。
早上货物扫描到站,由转趟司机运送到站,业务员进行派送。
进行货单、回单的签回,运费和代收货款的追收。
监督务必在12:00之前对早上到站货物派完,然后是收件流程--大客户固定时间取件,月结客户业务员约定时间取件,其他客户公司客服部电话通知业务员取件。
2023年操作系统作业调度实验报告
实验二作业调度实验题目1、编写并调试一个单道解决系统的作业等待模拟程序。
作业调度算法:分别采用先来先服务(FCFS),最短作业优先(SJF)的调度算法。
(1 )先来先服务算法:按照作业提交给系统的先后顺序来挑选作业,先提交的先被挑选。
(2)最短作业优先算法:是以进入系统的作业所提出的“执行时间”为标准,总是优先选取执行时间最短的作业。
二.实验目的:本实验规定用高级语言(C语言实验环境)编写和调试一个或多个作业调度的模拟程序,了解作业调度在操作系统中的作用,以加深对作业调度算法的理解三.实验过程〈一〉单道解决系统作业调度1)单道解决程序作业调度实验的源程序:zuoye.c 执行程序:zu o y e.exe2)实验分析:1、由于在单道批解决系统中,作业一投入运营,它就占有计算机的一切资源直到作业完毕为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所占用的CP U时限等因素。
2、每个作业由一个作业控制块JCB表达,JCB可以包含如下信息:作业名、提交时间、所需的运营时间、所需的资源、作业状态、链指针等等。
作业的状态可以是等待W(Wait)、运营R(Run)和完毕F(Finish)三种状态之一。
每个作业的最初状态else i f (p->n e e d time<min->need t ime) m in=p; p= p ->next;( while (p!=NULL);i f (iden) {i—;/ / pr i n tf ("\nt i m e =%d: \ t no JCB sub mib.. . wait . . . t ime);tim e s++;i f ( times> 10 0) {prin t f("\nru n t ime i s too Ion g . .. error z,) ;g etc h () ; ))e 1 s e{ru n ning(m i n, m) ;//调用running ()函数}} //forf i na 1 (); 〃调用r u nn i ng()函数)voi d fefs (int m)〃先来先服务算法(int i, iden;syst e m ("cl s ");i ni t a 1 ();f or(i=0;i<n;i++)(p= r ea d y; i d en=l;do{if (p-> s tate= = , W* & &p ->reach t i me<=t i mes) i d e n=0:i f (i d e n )p= p -> n ext;}while(p!=NULL&&iden);if (i d on){i——;prin tf(〃\ n没有满足规定的进程,需等待”);t imes++;i f (time s >1 0 0 ) {prin t f ("\n 时间过长");getch () ;})e 1 se{runn i ng(p, m); 〃调用r u nn i n g ()函数))final () ;//调用ru n n i n g ()函数}void muneO{int m;s y s tem (〃 c 1 s〃);p r i n t f (z/\ n\n\t\t *** 火 * ****** * ***** * ***** *** *** * *** * **** ***** **\ t \ t\n ");P rintf ('\t \ t \ t\t 作业调度演示\ n ");pr i ntf( " \t\t^ ***** * * *** * *** * ******** * * **** * ******** * * *** * \t\P r intf(*\n\n\n\t\ t \tl.先来先服务算法.;pr i nt f ("\n\t\ t \ t2.最短作业优先算法.;printfC\n\ t \ t \t3.响应比高者优先算法");prin t f ( ° \0.退出程序.;P rintfC \n\n\t \t\ t \t 选择所要操作:");s c anf (*%d*, &m);sw i tc h (m)(c ase 1:f c f s (m);getchO ;s y stem("c 1 s");mune();brea k ;c a se 2 :sjf (m):getch ();system ( " cis*);mune ();break;case 3 :hr n (m);g e t c h ();sys t em("cls");mune ();br e a k ;case 0:system ("cis");break;d e f a u 1 t :pr intf(〃选择错误,重新选择getchO ;system ("c Is");muneO ;))main ()//主函数(i niz e ();muneO ;)5)调试结果:i.选择操作的界面程课件'计算机操作系统联作系统实验八作业调度\zuoye.exe ,作业调度演示.先来先服务算法.1 .最短企业优先算法.2 .响应居意者优先萱法 4战出程序.选择所要操作:2.输入操作初始信息:c 「E:\课程课件'计算机》3 .先来先服务算法作业调度结果:(调度顺序:a -> b ->c->d->e )输入作业数:5输入作业数:5太人作业名:a7、侬、|到达时间:0要运行的时间:4 必法崎松时间其要运行的时间:3植入作业名:c 作业默认到达时间:2 曲人作批要运行的时间;5 植入作业名:d 伟业默认到达时间:3 曲入作要运行的时间;2 检入作业名:e 伟业默认到达时间;4 输入作业要运行的时间;4作业证在运行,估计其运行情况: 开始运宜时刻:。
作业调度算法实验报告
华中师范大学计算机科学系实验报告书实验题目:作业调度算法课程名称:操作系统主讲教师:叶俊民教授辅导教师:课程编号:84810117 (1)班级:0903班实验时间:2011.10.26一、实验目的:1、掌握作业调度的基本思想2、熟练使用各种作业调度算法描述的过程3、掌握各种算法的优缺点4、提高理论和实践结合的能力二、实验内容:1、先来先服务算法2、最短作业优先算法3、最高响应比优先算法三、实验环境:实践平台:linux编写环境:codeblocks编译器: g++四、实验设计原理1、先来先服务算法根据作业输入输入井的先后顺序调度作业即先到达输入井的作业先被调度,后到达的作业后调度2、最短作业算法根据作业需要运行的时间的长短来确定调用哪一个作业,即当前输入井中需要执行时间越短越早执行3、最高响应比优先算法输入井中的每一个作业根据当前运行的作业计算出作业的响应比,响应比最高的将被调度五、实验详细实现过程与算法流程1、先来先服务第一个进入输入井的作业先执行,那么该作业就有一个执行结束的时间,那么在该作业运行时间内,满足时间条件的作业进入输入井,然后根据前一个作业的运行结束的时间推算和下一个作业要进入输入井的时间推算下一个作业时间开始运行的时间:Time = max(curendtime,nextstarttime);这样后作业运行的开始时间就计算出来了,那么加上一个运行长度就是该作业的结束时间,周转时间即为结束时间减去进入输入井的时间2、最短作业优先算法这里设置一个优先队列,第一个作业先进入队列,第一个作业出队列,根据出队的作业的结束时间扫描能够满足条件的作业进入队列,重复如此操作直到作业调度完毕,在这个过程中,出队的作业,就能根据前一个作业的信息推算出当前作业的信息3、最高响应比优先算法这里采用了蛮力法:根据当前运行的作业的信息,再枚举输入井中等待运行的作业,算出等待运行作业的响应比,选择最大的执行,这样直到作业运行完毕六、实验调试与结果分析(问题的发现、分析、解决方案与创新)1、代码的界面开始让人看上去很烦,为了养成一个良好的编程习惯,就必须耐心的调试代码的风格和界面风格,要知道程序不是给你一个人看的,界面也不是给自己看的,得让他人看得明白和透彻2、采用了优先队列,效率比较高,且代码量小,编程容易,容易阅读3、程序中有很多小的错误,细节决定成败七、源程序(加注释)//作业调度程序#include<iostream>#include<cstdio>#include<cstring>#include<queue>#include<cstdlib>using namespace std;const int N=10000;struct node{char name[30];//作业的名字int Ctime; //作业进入输入井的时间(以分计)int Rtime; //作业的运行时间<以分计算>int Stime; //作业开始运行的时间int Etime; //作业运行结束的时间int Ttime; //作业周转时间float circle; //作业的周转周期}work[N];struct cmp{bool operator()(int i,int j){return work[i].Rtime>work[j].Rtime;}};int max (int a,int b){return a>b? a: b;}void FCFS();void SJF();void HRN();int main(){int op;while(1){printf("*****************************\n\n");printf(" 欢迎体验作业调度算法\n\n");printf(" 1.先来先服务\n\n");printf(" 2.最短作业优先法\n\n");printf(" 3.最高响应比算法\n\n");printf(" 0.退出\n\n");printf(" 请输入你的选择: ");scanf("%d",&op);switch(op){case 0: exit(0);case 1: FCFS();break; //跳转到先来先服务算法case 2: SJF();break; //跳转到最短优先服务算法case 3: HRN();break; // 跳转到最高响应比算法default :printf("\n 选择无效\n\n");}}return 0;}void FCFS(){int n,i,h,m;printf("******************************\n\n");printf(" 欢迎体验先来先服务算法 \n\n");printf(" 请输入作业的个数: ");scanf("%d",&n);printf("\n\n");printf(" 首先请按作业进入输入井时间的先后输入\n\n");printf(" 每个任务的格式为:\n\n 作业名称作业进入输入井的时间作业运行时间\n\n");printf(" ps: 进入输入井的时间格式为 h:m\n\n");printf(" 现在输入这%d个任务的信息\n",n);int pre;int sum = 0;double sum1=0;for(i=0;i<n;i++){getchar();printf("\n");printf(" 第%d个: ",i+1);scanf("%s",work[i].name);scanf("%d:%d",&h,&m);work[i].Ctime=h*60+m;scanf("%d",&work[i].Rtime);if(i==0){work[i].Stime=work[i].Ctime;work[i].Etime=work[i].Stime+work[i].Rtime;work[i].Ttime=work[i].Rtime;work[i].circle=(1.0*work[i].Ttime)/(1.0*work[i].Rtime);pre=work[i].Etime;}else{work[i].Stime=max(work[i].Ctime,pre);work[i].Etime=work[i].Stime+work[i].Rtime;work[i].Ttime=work[i].Etime-work[i].Ctime;work[i].circle=(1.0*work[i].Ttime)/(1.0*work[i].Rtime);pre=work[i].Etime;}sum+=work[i].Ttime;sum1+=work[i].circle;}printf("\n");printf(" 先来先服务算法运行结果如下:\n\n");printf(" 作业名进入时间运行时间开始时间结束时间周转时间带权周转时间\n\n");for(i=0;i<n;i++)printf(" %s %02d : %02d %4d %02d : %02d %02d : %02d %4d %.3lf\n\n",work[i].name, work[i].Ctime/60,work[i].Ctime%60, work[i].Rtime, work[i].Stime/60, work[i].Stime%60, work[i].Etime/60,work[i].Etime%60,work[i].Ttime,work[i].circle);printf(" 作业的平均周转时间为: %.3lf分钟\n\n",(1.0*sum)/(1.0*n));printf(" 作业的平均带权周期为: %.3lf\n\n",sum1/(1.0*n));printf(" 先来先服务算法体验结束\n\n");}void SJF(){bool vis[N];int n,h,m,i,j;printf("******************************\n\n");printf(" 欢迎体验最短作业优先算法 \n\n");printf(" 请输入作业的个数: ");scanf("%d",&n);printf("\n\n");printf(" 首先请按作业进入输入井时间的先后输入*时间相同的按执行时间长短输入*\n\n");printf(" 每个任务的格式为:\n\n 作业名称作业进入输入井的时间作业运行时间\n\n");printf(" ps: 进入输入井的时间格式为 h:m\n\n");printf(" 现在输入这%d个任务的信息\n\n",n);for( i=0;i<n;i++){getchar();printf("\n");printf(" 第%d个: ",i+1);scanf("%s",work[i].name);scanf("%d:%d",&h,&m);work[i].Ctime=h*60+m;scanf("%d",&work[i].Rtime);}priority_queue<int, vector<int>, cmp> Que;memset(vis,0,sizeof(vis));int num=0;int pre=0;int sum=0;double sum1=0;while(num<n){vis[num]=true;Que.push(num);num++;while(!Que.empty()){int u=Que.top();Que.pop();work[u].Stime=max(pre,work[u].Ctime);//作业开始时间work[u].Etime=work[u].Stime+work[u].Rtime;work[u].Ttime=work[u].Etime-work[u].Ctime;work[u].circle=(1.0*work[u].Ttime)/(1.0*work[u].Rtime);sum+=work[u].Ttime;sum1+=work[u].circle;pre=work[u].Etime;if(num<n){int tag=0;for( j=1;j<n;j++){if(vis[j]==false&&work[u].Etime>=work[j].Ctime){Que.push(j);num++;vis[j]=true;tag=1;}}}}}printf("\n");printf(" 先来先服务算法运行结果如下:\n\n");printf(" 作业名进入时间运行时间开始时间结束时间周转时间带权周转时间\n\n");for(i=0;i<n;i++)printf(" %s %02d : %02d %4d %02d : %02d %02d : %02d %4d %.3lf\n\n",work[i].name, work[i].Ctime/60,work[i].Ctime%60, work[i].Rtime, work[i].Stime/60, work[i].Stime%60, work[i].Etime/60,work[i].Etime%60,work[i].Ttime,work[i].circle);printf(" 作业的平均周转时间为: %.3lf分钟\n\n",(1.0*sum)/(1.0*n));printf(" 作业的平均带权周期为: %.3lf\n\n",sum1/(1.0*n));printf(" 先来先服务算法体验结束\n\n");}void HRN(){bool vis[N];int n,h,m,i,j,k;printf("******************************\n\n");printf(" 欢迎体验最短作业优先算法 \n\n");printf(" 请输入作业的个数: ");scanf("%d",&n);printf("\n\n");printf(" 首先请按作业进入输入井时间的先后输入*时间相同的按执行时间长短输入*\n\n");printf(" 每个任务的格式为:\n\n 作业名称作业进入输入井的时间作业运行时间\n\n");printf(" ps: 进入输入井的时间格式为 h:m\n\n");printf(" 现在输入这%d个任务的信息\n\n",n);for( i=0;i<n;i++){getchar();printf("\n");printf(" 第%d个: ",i+1);scanf("%s",work[i].name);scanf("%d:%d",&h,&m);work[i].Ctime=h*60+m;scanf("%d",&work[i].Rtime);}work[0].Stime=work[0].Ctime;work[0].Etime=work[0].Stime+work[0].Rtime;work[0].Ttime=work[0].Rtime;work[0].circle=1;int sum=work[0].Ttime;double sum1=work[0].circle;int pre=work[0].Etime;memset(vis,0,sizeof(vis));vis[0]=true;for(i=1;i<n;i++){k=-1;double max1=1;for(j=1;j<n;j++){if(vis[j]==false&&work[j].Ctime<=pre){int startime=pre;// cout << startime << endl;int ttime=(startime+work[j].Rtime-work[j].Ctime);//预计周转时间//cout << ttime << endl;double rt=(1.0*ttime)/(1.0*work[j].Rtime);if(rt>max1){max1=rt;k=j;}}}//printf("%.3lf\n",max1);if(k!=-1){vis[k]=true;work[k].Stime=max(pre,work[k].Ctime);work[k].Etime=work[k].Stime+work[k].Rtime;work[k].Ttime=work[k].Etime-work[k].Ctime;work[k].circle=(1.0*work[k].Ttime)/(1.0*work[k].Rtime);pre=work[k].Etime;sum+=work[k].Ttime;sum1+=work[k].circle;}else{for(j=1;j<n;j++)if(vis[j]==false)break;work[j].Stime=work[j].Ctime;work[j].Etime=work[j].Stime+work[j].Rtime;work[j].Ttime=work[j].Rtime;work[j].circle=1;vis[j]=true;pre=work[j].Etime;sum+=work[j].Ttime;sum1+=work[j].circle;}}printf("\n");printf(" 先来先服务算法运行结果如下:\n\n");printf(" 作业名进入时间运行时间开始时间结束时间周转时间带权周转时间\n\n");for(i=0;i<n;i++)printf(" %s %02d : %02d %4d %02d : %02d %02d : %02d %4d %.3lf\n\n",work[i].name, work[i].Ctime/60,work[i].Ctime%60, work[i].Rtime, work[i].Stime/60, work[i].Stime%60, work[i].Etime/60,work[i].Etime%60,work[i].Ttime,work[i].circle);printf(" 作业的平均周转时间为: %.3lf分钟\n\n",(1.0*sum)/(1.0*n));printf(" 作业的平均带权周期为: %.3lf\n\n",sum1/(1.0*n));printf(" 最高响应比算法体验结束\n\n");}八、实验结果分析数据:job1 8:00 120job2 8:50 50job3 9:00 10job4 9:50 20先来先服务算法:job1 08 : 00 120 08 : 00 10 : 00 120 1.000 job2 08 : 50 50 10 : 00 10 : 50 120 2.400job3 09 : 00 10 10 : 50 11 : 00 120 12.000job4 09 : 50 20 11 : 00 11 : 20 90 4.500平均周转时间为 112.5平均带权周转时间为 4.975分析:job1先进入输入井,结束时间就为10:00那么job2第二个进入输入井,他只能等job1执行完了之后才能执行故job2的开始时间为10:00,job3,job4 同理最短作业优先:job1 08 : 00 120 08 : 00 10 : 00 120 1.000job2 08 : 50 50 10 : 30 11 : 20 150 3.000job3 09 : 00 10 10 : 00 10 : 10 70 7.000job4 09 : 50 20 10 : 10 10 : 30 40 2.000平均周转时间为 95平均带权周转时间为 3.250分析:job1先运行,结束时间为10:00,那么在10:00之前进入输入井的job2、job3、job4都进入优先队列,运行时间最短的job3出队,之后job4出队,最后job2调用最高响应比:job1 08 : 00 120 08 : 00 10 : 00 120 1.000 job2 08 : 50 50 10 : 10 11 : 00 130 2.600job3 09 : 00 10 10 : 00 10 : 10 70 7.000job4 09 : 50 20 11 : 00 11 : 20 90 4.500平均周转时间为 102.500平均带权周转时间为 3.775分析:job1先调用,根据job1的结束时间10:00,选择10:00之前的任务都进入输入井,那么job2、job3、job4都进入输入井,之后输入井中的每一个任务都以job1为基础计算出相对于job1的响应比,最高的开始执行,执行完以后又以执行完以后的任务为基础计算所有输入井中的任务的响应比,选择最高的运行,如此运行直到结束九实验改进意见与建议实验比较简单,但是细节地方很烦,注意代码风格,多加注释可能有一些数据没有考虑到,一些比较特殊的数据可能会出现错误。
操作系统实验报告作业调度
操作系统实验报告作业调度操作系统实验报告:作业调度引言:操作系统是计算机系统中最核心的软件之一,它负责管理计算机的资源,为用户提供良好的使用环境。
在操作系统中,作业调度是非常重要的一部分,它决定了计算机如何合理地分配和调度各个作业的执行顺序,以提高计算机的效率和性能。
本实验报告将介绍作业调度的概念、调度算法以及实验结果。
一、作业调度的概念作业调度是指根据一定的策略和算法,将就绪队列中的作业按照一定的顺序分配给处理器,使得计算机系统能够充分利用资源,提高系统的吞吐量和响应时间。
作业调度的目标是实现公平性、高效性和平衡性。
二、作业调度的算法1. 先来先服务(FCFS)调度算法FCFS调度算法是最简单的调度算法之一,它按照作业的到达顺序进行调度,先到达的作业先执行。
这种算法的优点是简单易实现,但是可能会导致长作业等待时间过长,造成资源浪费。
2. 最短作业优先(SJF)调度算法SJF调度算法是根据作业的执行时间来进行调度,执行时间短的作业先执行。
这种算法能够最大程度地减少平均等待时间,提高系统的响应速度,但是可能会导致长作业长时间等待。
3. 优先级调度算法优先级调度算法是根据作业的优先级来进行调度,优先级高的作业先执行。
这种算法可以根据不同的需求设置不同的优先级,但是可能会导致低优先级的作业长时间等待。
4. 时间片轮转调度算法时间片轮转调度算法是将处理器的执行时间划分为多个时间片,每个作业在一个时间片内执行,时间片用完后,将处理器分配给下一个作业。
这种算法可以实现公平性,但是可能会导致长作业等待时间过长。
三、实验结果与分析在本次实验中,我们使用了不同的作业调度算法,并对其进行了性能测试。
测试结果显示,FCFS算法在平均等待时间方面表现较差,而SJF算法和优先级调度算法在平均等待时间方面表现较好。
时间片轮转调度算法能够实现公平性,但是可能会导致长作业等待时间过长。
结论:作业调度是操作系统中的重要组成部分,合理的作业调度算法能够提高计算机系统的效率和性能。
作业调度算法-实验报告
作业调度算法模拟一、课题内容和要求常见的作业调度算法有先来先服务算法、最短作业优先算法、响应比优先调度算法。
(1)参考操作系统教材理解这3种算法。
(2)实现这3个算法。
(3)已知若干作业的到达时间和服务时间,用实现的算法计算对该组作业进行调度的平均周转时间Ttime和平均带权周转时间WTtime。
(4)作业的到达时间和服务时间可以存放在文本文件record.txt中。
(5)设计简单的交互界面,演示所设计的功能。
(可以使用MFC进行界面的设计) (6)可根据自己能力,在完成以上基本要求后,对程序功能进行适当扩充。
二、需求分析模拟实现作业调度算法,包括:FCFS(先来先服务算法)、SJF(短作业优先算法)、HRN(最高响应比优先算法)、HPF(基于优先数调度算法)。
先来先服务算法:按照各个作业进入系统(输入井)的自然次序来调度算法。
短作业优先算法:优先调度并处理短作业。
所谓的“短作业”并不是指物理作业长度短,而是指作业的运行时间短。
最高响应比优先算法:优先调度并处理响应比最高的作业。
三、概要设计函数中一些类:1、2、先来先服务:3、最短作业优先:4、最高响应比:四、详细设计1、程序代码MFC头文件a.h内容:const int defMaxJobNumber = 10; //作业数量的最大值class Time //时间类{public:int hour;int minute;};class Job//作业类{public:int ID; //作业编号Time enter; //进入时间int requesttime; //估计运行时间int priority; //优先数Time start; //开始时间Time end; //结束时间int Ttime; //周转时间double WTtime; //带权周转时间};class schedule //调度类{public:int size; //作业数Job *job; //作业数组int *r; //排序用数组int Differ(Time t1,Time t2) //求两个时刻间的时间差t2-t1{int borrow = (t2.minute<t1.minute) ? 1 : 0;return ((t2.hour-t1.hour-borrow)*60+(borrow*60+t2.minute-t1.minute));}public:schedule() //构造函数{size = 0;job = new Job[defMaxJobNumber];r = new int[defMaxJobNumber-1];}void readFile() //从文件读信息{ifstream txtfile;txtfile.open("record.txt");int i = 0;int entertime;while(!txtfile.eof()){txtfile>>job[i].ID>>entertime>>job[i].requesttime>>job[i].priority;job[i].enter.hour = entertime / 100; //取小时job[i].enter.minute = entertime % 100; //取分钟i++;size++;}txtfile.close();}void FCFS()//先来先服务(First Come First Serve){int hour,minute,carry;job[0].start = job[0].enter;hour = job[0].requesttime / 60;minute = job[0].requesttime % 60;job[0].end.minute = (job[0].start.minute + minute) % 60;carry = (job[0].start.minute + minute) / 60; //carry是分钟累积超过60商job[0].end.hour = job[0].start.hour + hour + carry;job[0].Ttime = job[0].requesttime;job[0].WTtime = ((double)job[0].Ttime) / job[0].requesttime;for(int i=1;i<size;i++){job[i].start = job[i-1].end;hour = job[i].requesttime / 60;minute = job[i].requesttime % 60;job[i].end.minute = (job[i].start.minute + minute) % 60;carry = (job[i].start.minute + minute) / 60;job[i].end.hour = job[i].start.hour + hour + carry;job[i].Ttime = Differ(job[i].enter,job[i].end); //周转时间job[i].WTtime = ((double)job[i].Ttime) / job[i].requesttime; //带权周转时间}}void SJF()//短作业优先(Shortest Job First){int hour,minute,carry;job[0].start = job[0].enter;hour = job[0].requesttime / 60;minute = job[0].requesttime % 60;job[0].end.minute = (job[0].start.minute + minute) % 60;carry = (job[0].start.minute + minute) / 60; //carry是分钟累积超过60的商job[0].end.hour = job[0].start.hour + hour + carry;job[0].Ttime = job[0].requesttime; //周转时间job[0].WTtime = ((double)job[0].Ttime) / job[0].requesttime; //带权周转时间for(int i=1;i<size;i++)r[i] = i;for(i=1;i<size-1;i++) //按照作业运行时间从低到高排序{int index = i;for(int j=i+1;j<size;j++)if(job[r[j]].requesttime<job[r[index]].requesttime)index = j;if(index!=i){int w = r[i];r[i] = r[index];r[index] = w;}}int dest=0;for(i=1;i<size;i++) //按排序后的作业序继续执行{int index = r[i];job[index].start = job[dest].end;hour = job[index].requesttime / 60;minute = job[index].requesttime % 60;job[index].end.minute = (job[index].start.minute + minute) % 60;carry = (job[index].start.minute + minute) / 60;job[index].end.hour = job[index].start.hour + hour + carry;job[index].Ttime = Differ(job[index].enter,job[index].end);job[index].WTtime = ((double)job[index].Ttime) / job[index].requesttime;dest = index;}}void HRN() //最高响应比优先(Highest Response_ratio Next){int hour,minute,carry;job[0].start = job[0].enter;hour = job[0].requesttime / 60;minute = job[0].requesttime % 60;job[0].end.minute = (job[0].start.minute + minute) % 60;carry = (job[0].start.minute + minute) / 60; //carry是分钟累积超过60的商job[0].end.hour = job[0].start.hour + hour + carry;job[0].Ttime = job[0].requesttime; //周转时间job[0].WTtime = ((double)job[0].Ttime) / job[0].requesttime; 带权周转时间int dest=0;for(int i=1;i<size;i++)r[i] = i;for(i=1;i<size;i++){int index = i;for(int j=i+1;j<size;j++) //按照响应比从大到小排序if(((double)Differ(job[r[j]].enter,job[dest].end))/job[r[j]].requesttime>((double)Differ(job[r[index]].enter,job[dest].end))/job[r[index]].requesttime)//响应比=作业周转时间/作业处理时间index = j;if(index!=i){int w = r[i];r[i] = r[index];r[index] = w;}//按排序后的作业序继续执行index = r[i];job[index].start = job[dest].end;hour = job[index].requesttime / 60;minute = job[index].requesttime % 60;job[index].end.minute = (job[index].start.minute + minute) % 60;carry = (job[index].start.minute + minute) / 60;job[index].end.hour = job[index].start.hour + hour + carry;job[index].Ttime = Differ(job[index].enter,job[index].end);job[index].WTtime = ((double)job[index].Ttime) / job[index].requesttime;dest = index;}}};五、测试数据及其结果分析从文本文件中读取数据(书上的例子):1 800 120 22 850 50 33 900 10 14 950 20 4输出的平均周转时间、平均带权周转时间结果正确。
作业调度实验报告
作业调度一、实验要求:编写一个作业调度程序,用一种调度算法,实现对一个给定的作业序列的调度。
并计算平均周转时间和加权周转时间。
二、设计思想: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、对于给定的一组作业, 给出其到达时间和运行时间,例如下表所示:作业名 A B C D E F到达时间0 2 5 5 12 15服务时间 6 50 20 10 40 82、分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。
3、计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。
三、主要算法流程图开始响应比高者优先短作业优先先来先服务算法生成调度顺序队列计算平均周转时间及平均带权周转时间结束退出系统YN四、测试数据及运行结果测试数据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'] 周转时间:74.1666666667 带权周转时间:4.83333333333短作业优先算法调度顺序:['A', 'D', 'F', 'C', 'E', 'B']周转时间:44.8333333333带权周转时间:1.166********响应比高者优先算法调度顺序:['A', 'D', 'F', 'E', 'C', 'B']周转时间:48.1666666667带权周转时间:1.5五、代码#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:listdd.append(work2)if len(listdd)!=0:li = sorted(listdd, key=lambda s: s['服务时间'])resultlist.append(li[0])list.remove(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['到达时间']listdd.append(work2)if len(listdd)!=0:li = sorted(listdd, key=lambda s: (s['等待时间']+s['服务时间'])/s['服务时间'])resultlist.append(li[-1])list.remove(li[-1])ctime+=li[-1]['服务时间']listdd=[]return resultlist#调度顺序def shunxu(resultlist,miaoshu):print(miaoshu)ddsx=[]for work in resultlist:for d,x in work.items():if d.decode('gb2312')==u'作业名':ddsx.append(x)#print d.decode('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*1.0/len(resultlist)))print('带权周转时间:'+str(dqzzsj*1.0/len(resultlist)))print('')shunxu(fcfs(list1),'先来先服务算法') shunxu(sjf(list2),'短作业优先算法') shunxu(hrrn(list3),'响应比高者优先算法')。
操作系统实验报告作业调度
操作系统实验报告作业调度作业调度是操作系统中的一个重要组成部分,用于管理和分配计算机系统中的作业,确保系统可靠高效地运行。
作业调度算法的选择直接影响到系统的性能和资源利用率。
本实验通过对不同作业调度算法的理论分析和实际测试,探究它们的特点和优劣,最终找到适合特定场景的作业调度算法。
以下是本次实验的详细报告。
一、实验目的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、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验二作业调度
一.实验题目
1、编写并调试一个单道处理系统的作业等待模拟程序。
作业调度算法:分别采用先来先服务(FCFS),最短作业优先(SJF)、响应比高者优先(HRN)的调度算法。
(1)先来先服务算法:按照作业提交给系统的先后顺序来挑选作业,先提交的先被挑选。
(2)最短作业优先算法:是以进入系统的作业所提出的“执行时间”为标准,总是优先选取执行时间最短的作业。
(3)响应比高者优先算法:是在每次调度前都要计算所有被选作业(在后备队列中)的响应比,然后选择响应比最高的作业执行。
2、编写并调度一个多道程序系统的作业调度模拟程序。
作业调度算法:采用基于先来先服务的调度算法。
可以参考课本中的方法进行设计。
对于多道程序系统,要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。
二.实验目的:
本实验要求用高级语言(C语言实验环境)编写和调试一个或多个作业调度的模拟程序,了解作业调度在操作系统中的作用,以加深对作业调度算法的理解
三 .实验过程
<一>单道处理系统作业调度
1)单道处理程序作业调度实验的源程序:
执行程序:
2)实验分析:
1、由于在单道批处理系统中,作业一投入运行,它就占有计算机的一切资源直到作业完成为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所占用的 CPU 时限等因素。
2、每个作业由一个作业控制块JCB 表示,JCB 可以包含如下信息:作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。
作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。
每个作业的最初状态总是等待W 。
3、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间,以及这组作业的平均周转时间及带权平均周转时间。
3)流程图:
二.最短作业优先算法
三.高响应比算法
图一.先来先服务流程图
4)源程序:
#include <>
#include <>
#include <>
#define getpch(type) (type*)malloc(sizeof(type))
#define NULL 0
int n;
代替
代替
float T1=0,T2=0;
int times=0;
struct jcb .\n",p->name);
free(p); .wait...",time); if(times>1000)
{printf("\nruntime is too long...error...");getch();}
}
else
{
running(min,m); .wait...",time);
times++;
if(times>100){printf("\nruntime is too long...error");getch();}
}
else{
running(min,m); 来先服务算法.");
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();
}
}
main() 择操作的界面
2.输入操作初始信息:
3.先来先服务算法作业调度结果: (调度顺序:a->b->c->d->e)
4.最短作业优先算法作业调度结果(调度顺序: a->d->b->e->c)
5.高响应比算法作业调度结果: (调度顺序 a->b->d->c->e)
<二>多道处理系统作业调度
1)多道处理程序作业调度实验的源程序:
执行程序:
2)实验分析:
采用多道程序设计方法的操作系统,在系统中要经常保留多个运行的作业,以提高系统效率。
作业调度从系统已接纳的暂存在输入井中的一批作业中挑选出若干个可运行的作业,并为这些被选中的作业分配所需的系统资源。
对被选中运行的作业必须按照它们各自的作业说明书规定的步骤进行控制。
采用先来先服务算法算法模拟设计作业调度程序。
(1)、作业调度程序负责从输入井选择若干个作业进入主存,为它们分配必要的资源,当它们能够被进程调度选中时,就可占用处理器运行。
作业调度选择一个作业的必要条件是系统中现有的尚未分配的资源可满足该作业的资源要求。
但有时系统中现有的尚未分配的资源既可满足某个作业的要求也可满足其它一些作业的要求,那么,作业调度必须按一定的算法在这些作业中作出选择。
先来先服务算法是按照作业进入输入井的先后次序来挑选作业,先进入输入井的作业优先被挑选,当系统中现有的尚未分配的资源不能满足先进入输入井的作业时,那么顺序挑选后面的作业。
(2)假定某系统可供用户使用的主存空间共100k,并有5台磁带机。
3)流程图:
4)源程序:
#include <>
#include <>
#include <>
#define getpch(type) (type*)malloc(sizeof(type))
#define NULL 0
int j=0;
int n,i; int times=0; struct jcb 道作业调度演示."); printf("\n\t\t0.退出程序");
printf("\n\t\t\t选择所要的操作:");
printf("\n\n\n\t\t\t\t\t计算机学院软件四班\n");
printf("\t\t\t\t\t蓝小花\n");
printf("\t\t\t\t\t完成日期:2006年12月");
scanf("%d",&m);
switch(m)
{
case 1:
system("cls");
inital();
apply();
running();
getch();
system("cls");
main();
break;
case 0:
system("cls");
break;
default:
system("cls");
main();
}
}
5)调试结果:
1) 界面跟前面的其他几个实验的界面大同小异,这里就不在重复出现界面.下面输出的是作业的初始信息:
2)调度作业,此时的作业情况如下:
3)按回车键,相当于作业继续调度,如下:
4)重复3>,直至作业运行结束;
四.思考题:
1.写出每种算法的调度策略,最后比较各种算法的优缺点。
答:①FCFS算法总是把处理机分配给最先进入就绪队列的进程,一个进程一旦分得处理机,便执行下去,直到该进程完成或阻塞时,才释放
处理机。
优点:实现简单. 缺点:没考虑进程的优先级
②SJF算法从就绪队列中选出“下一个CPU执行期”最短的进程,为
之分配处理机。
该算法虽可获得较好的调度性能,但难以准确地知道下一个CPU
执行期,而只能根据每一个进行的执行历史来预测。
③ HRN算法既照顾了短作业,又照顾了作业顺序,不会使长作业长期
得不到运行,但调度前,必须计算响应比,增加了系统的开销.
2.选择调度算法的依据是什么
答:面向用户的准则:周转时间短;响应时间快;截止时间的保证;优先权准则
面向系统的准则:系统吞吐量高;处理机利用率好;各类资源的平衡利用
五.心得体会
每个人对作业调度的算法都存在着一定的理解,这也就是很多同学的算法实现不同的原因.可能是自己理解的不够透彻,我总觉得自己的实验不够完善,还有,可能是自己掌握c语言还不够深,总觉得自己的想法与实现的算法存在着很大差距.希望通过更多的实验,让自己有更大的提高.。