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

合集下载

作业调度实验报告

作业调度实验报告

作业调度实验报告一、实验目的1.掌握作业调度的概念和基本原则;2.理解作业调度算法的原理和实现方式;3.熟悉作业调度过程中的各种参数和指标;4.进一步了解操作系统中的进程调度机制。

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

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

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

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

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

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

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

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

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

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

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

操作系统调度算法实验报告

操作系统调度算法实验报告

操作系统调度算法实验报告
本实验旨在研究不同操作系统调度算法在实际应用中的表现和影响。

我们选择了三种常见的调度算法进行对比分析,分别是先来先服务(FCFS)、最短作业优先(SJF)和时间片轮转(RR)。

1. 实验准备
在开始实验之前,我们首先搭建了一个简单的模拟环境,包括一个CPU和多个进程。

每个进程具有不同的执行时间,以便模拟不同情况
下的调度效果。

2. 先来先服务(FCFS)
先来先服务是最简单的调度算法之一,即根据进程到达的顺序依次
执行。

实验结果显示,FCFS算法适用于处理大量长作业,但当出现短
作业时会导致平均等待时间较长。

3. 最短作业优先(SJF)
最短作业优先算法会优先执行执行时间最短的进程,以减少平均等
待时间。

在我们的实验中,SJF算法表现出色,尤其在短作业较多的情
况下,能够显著提高系统的响应速度。

4. 时间片轮转(RR)
时间片轮转算法将CPU时间分配给每个进程,每个进程执行一个
时间片后轮转到下一个进程。

然而,RR算法可能导致上下文切换频繁,
影响系统效率。

在实验中,我们发现RR算法在处理多任务时效果较好,但在处理长时间任务时表现一般。

5. 实验总结
通过对三种调度算法的实验比较,我们可以看出不同算法在不同情
况下有着不同的优势和劣势。

在实际应用中,需要根据具体情况选择
合适的调度算法,以提高系统的性能和效率。

希望本实验能为操作系
统调度算法的研究提供一定的参考价值。

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

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

操作系统实验报告作业调度操作系统实验报告:作业调度引言作业调度是操作系统中的重要部分,它负责管理和调度系统中的各种作业,以最大化系统资源的利用率和提高作业的执行效率。

在本次实验中,我们将探讨作业调度的基本原理和实现方法,并通过实验验证其效果。

实验目的本次实验的主要目的是通过实际操作,了解作业调度的基本原理和实现方法,掌握作业调度的相关算法,并通过实验验证其有效性。

实验内容1. 实现作业调度的基本算法在本次实验中,我们将实现作业调度的基本算法,包括先来先服务(FCFS)、最短作业优先(SJF)、优先级调度(Priority Scheduling)和多级反馈队列调度(Multilevel Feedback Queue Scheduling)等。

通过编写代码,模拟这些算法的执行过程,并观察它们的效果。

2. 实验验证我们将设计一些测试用例,通过模拟作业的执行过程,分别使用不同的作业调度算法,并比较它们的执行效果。

通过实验验证,我们将得出不同算法的优劣势,并分析其适用场景。

实验结果经过实验验证,我们得出以下结论:1. 先来先服务(FCFS)算法适用于作业执行时间相对均匀的情况,但可能会导致平均等待时间较长。

2. 最短作业优先(SJF)算法能够最大程度地减少平均等待时间,但可能会出现作业饥饿现象。

3. 优先级调度(Priority Scheduling)算法能够根据作业的优先级进行调度,适用于有明确优先级需求的情况。

4. 多级反馈队列调度(Multilevel Feedback Queue Scheduling)算法能够根据作业的执行情况动态调整优先级,适用于各种类型的作业。

结论作业调度是操作系统中的重要组成部分,不同的作业调度算法适用于不同的场景。

通过本次实验,我们深入了解了作业调度的基本原理和实现方法,掌握了不同算法的优劣势,并通过实验验证了它们的有效性。

这将对我们进一步深入学习操作系统和提高系统性能有着重要的意义。

操作系统——作业调度

操作系统——作业调度

操作系统——作业调度实验⼆作业调度模拟程序⼀、⽬的和要求 1. 实验⽬的 (1)加深对作业调度算法的理解; (2)进⾏程序设计的训练。

2.实验要求 ⽤⾼级语⾔编写⼀个或多个作业调度的模拟程序。

单道批处理系统的作业调度程序。

作业⼀投⼊运⾏,它就占有计算机的⼀切资源直到作业完成为⽌,因此调度作业时不必考虑它所需要的资源是否得到满⾜,它所运⾏的时间等因素。

作业调度算法: 1) 采⽤先来先服务(FCFS)调度算法,即按作业到达的先后次序进⾏调度。

总是⾸先调度在系统中等待时间最长的作业。

2) 短作业优先 (SJF) 调度算法,优先调度要求运⾏时间最短的作业。

3) 响应⽐⾼者优先(HRRN)调度算法,为每个作业设置⼀个优先权(响应⽐),调度之前先计算各作业的优先权,优先数⾼者优先调度。

RP (响应⽐)=作业周转时间 / 作业运⾏时间=1+作业等待时间/作业运⾏时间每个作业由⼀个作业控制块JCB表⽰,JCB可以包含以下信息:作业名、提交(到达)时间、所需的运⾏时间、所需的资源、作业状态、链指针等等。

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

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

⼀、模拟数据的⽣成 1.允许⽤户指定作业的个数(2-24),默认值为5。

2. 允许⽤户选择输⼊每个作业的到达时间和所需运⾏时间。

3.(**)从⽂件中读⼊以上数据。

4.(**)也允许⽤户选择通过伪随机数指定每个作业的到达时间(0-30)和所需运⾏时间(1-8)。

⼆、模拟程序的功能 1.按照模拟数据的到达时间和所需运⾏时间,执⾏FCFS, SJF和HRRN调度算法,程序计算各作业的开始执⾏时间,各作业的完成时间,周转时间和带权周转时间(周转系数)。

2. 动态演⽰每调度⼀次,更新现在系统时刻,处于运⾏状态和等待各作业的相应信息(作业名、到达时间、所需的运⾏时间等)对于HRRN算法,能在每次调度时显⽰各作业的响应⽐R情况。

操作系统实验报告——调度算法

操作系统实验报告——调度算法

操作系统实验报告——调度算法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. 实验总结本次实验通过模拟不同调度算法的实际执行过程,深入了解了各种调度算法的原理、特点和适用场景。

通过对实验结果的分析,我们可以更好地选择合适的调度算法来满足实际应用的需求。

在后续的学习中,我们将进一步探索更多操作系统相关的实验和算法。

作业调度实验报告

作业调度实验报告

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

二、实验环境本次实验在 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. 分析不同作业调度算法在不同场景下的优缺点。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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作业证在运行,估计其运行情况: 开始运宜时刻:。

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

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

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

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

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

然后把它放入就绪队列。

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

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

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

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

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

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

该优先级的变化规律可以描述为:优先权 = (等待时间 + 要求服务时间)/要求服务时间三、实验内容源程序:#include<stdio.h>#include<stdlib.h>#include<time.h>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; //数据域s truct sjf_work * pNext; //指针域}NODE,*PNODE;void FCFS();void SJF();void showmenu();bool Is_empty(PNODE pHead);int cnt_work(PNODE pHead);PNODE do_work(PNODE pHead,int *w_finish_time,int i);void show(int *w_finish_time,int i,PNODE q,int*w_rel_time);void HRRN();PNODE priorit(PNODE pHead);void do_work_1(PNODE pHead,int *w_finish_time,int i);int main(){i nt choice; //设置选择数s howmenu(); //显示菜单s canf("%d",&choice);w hile(choice != 0) //选择算法{switch(choice){case 1 :printf("您选择的是先来先服务算法:\n");FCFS();break;case 2 :printf("您选择的是短作业优先算法:\n");SJF();break;case 3 :printf("您选择的是高响应比优先调度算法\n");HRRN();break;default:printf("请重新选择!");break;}printf("\n");printf("下面是菜单,请继续,或者按‘0’退出"); showmenu();scanf("%d",&choice);}p rintf("感谢您使用本系统,再见!");r eturn 0;}void FCFS(){i nt j,k;i nt w_rel_time[5];i nt w_finish_time[5];f loat rel_time = 0;struct work temp;i nt i;s truct work w[5];s rand(time(0));f or(i=0;i<5;i++){w[i].id = 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; //定义该链表有头结点,且第一个节点初始化为空f or(i=0;i<10;i++){PNODE pNew = (PNODE)malloc(sizeof(NODE));if (NULL == pNew){printf("分配失败, 程序终止!\n");exit(-1);}pNew->s_work.id = rand()%100;pNew->s_work.arrive_time = rand()%10;pNew->s_work.work_time = rand()%10+1;pTail->pNext = pNew;pNew->pNext = NULL;pTail = pNew;}P NODE p = pHead->pNext; //p指向第一个节点w hile (NULL != p){printf("第%d个作业的编号是:%d\t",j+1,p->s_work.id);printf("第%d个作业到达时间:%d\t",j+1,p->s_work.arrive_time);printf("第%d个作业服务时间:%d\t",j+1,p->s_work.work_time);printf("\n");p = p->pNext;printf("\n");j++;}p = pHead->pNext;P NODE q = p; //p,q都指向第一个节点p = p->pNext;w hile(p != NULL){if(p->s_work.arrive_time < q->s_work.arrive_time)q = p;p = p->pNext;}P NODE r = pHead->pNext; //r也指向第一个节点i nt cnt = 0; //记录所有节点数据域中到达时间最短且相等的个数w hile(r!= NULL){if( r->s_work.arrive_time == q->s_work.arrive_time ) cnt++;r = r->pNext;}p = pHead->pNext;w hile(p != NULL) //在相等到达时间的作业中找服务时间最短的作业{if(cnt > 1){if( p->s_work.arrive_time ==q->s_work.arrive_time )if( p->s_work.work_time < q->s_work.work_time )q = p;p = p->pNext;}elsep =NULL;} //确定q所指作业最先到达且服务时间最短w_finish_time[0] = q->s_work.arrive_time +q->s_work.work_time;w_rel_time[0] = w_finish_time[0] -q->s_work.arrive_time;p rintf("第1个系统执行的作业到达时间:%d",q->s_work.arrive_time);p rintf("编号是:%d ",q->s_work.id);p rintf("服务时间是:%d \n",q->s_work.work_time); p rintf("完成时间是:%d ",w_finish_time[0]);p rintf("周转时间是:%d \n",w_rel_time[0]);p = pHead; //寻找q的前一个节点,方便删掉q节点w hile( p->pNext != q ){p = p->pNext;}p->pNext = q->pNext;f ree(q);q = NULL;f or(i=0;i<9&&!Is_empty(pHead);i++){printf("现在系统还剩%d个作业!\n",cnt_work(pHead));q = do_work(pHead,w_finish_time,i);show(w_finish_time,i,q,w_rel_time);p = pHead; //寻找q的前一个节点,方便删掉q节点while( p->pNext != q ){p = p->pNext;}p->pNext = q->pNext;free(q);q = NULL;}f or(j=0;j<10;j++)rel_time += w_rel_time[j];}printf("平均周转时间:%f\n",rel_time/10);}bool Is_empty(PNODE pHead) //判断作业是否做完{P NODE p;p = pHead->pNext;i nt len = 0;w hile(p != NULL){len++;p = p->pNext;}i f(len == 0)return true; //当没有作业时,返回为真e lsereturn false;}int cnt_work(PNODE pHead) //计算当前还剩多少作业{P NODE p;p = pHead->pNext;i nt len = 0;w hile(p != NULL){len++;p = p->pNext;}r eturn len;}PNODE do_work(PNODE pHead,int *w_finish_time,int i) {P NODE p,q;i nt cnt = 0; //计数器清0,计算当前作业完成时,系统中有多少个作业已经到达p = pHead->pNext;q = p;w hile(p != NULL){if( p->s_work.arrive_time <= w_finish_time[i] ){cnt ++;q = p;p = p->pNext;}else{p = p->pNext;}} //q指向当前到达时间小于刚刚完成的作业,但不一定是服务时间最短的(如果有的话)p rintf("系统中有%d个作业在当前作业完成时已经到达!\n",cnt);p = pHead->pNext;w hile(p != NULL){if(cnt>1) //执行此次判断后,q现在指向所有条件都满足的作业(如果有的话){if( p->s_work.arrive_time <= w_finish_time[i] ){if( p->s_work.work_time < q->s_work.work_time ){q = p;p = p->pNext;}elsep = p->pNext;}elsep = p->pNext;}else //当前作业完成时,没有作业到达的情况{p = p->pNext; //用q来接收最先到达的,用p来遍历while( p != NULL ){if( p->s_work.arrive_time<q->s_work.arrive_time )q = p;p = p->pNext;}w_finish_time[i+1] = q->s_work.arrive_time + q->s_work.work_time;}}w_finish_time[i+1] = w_finish_time[i] +q->s_work.work_time;r eturn q;}void show(int *w_finish_time,int i,PNODE q,int*w_rel_time){w_finish_time[i+1] = w_finish_time[i] +q->s_work.work_time;w_rel_time[i+1] = w_finish_time[i+1] -q->s_work.arrive_time;p rintf("第%d个系统执行的作业到达时间:%d",i+2,q->s_work.arrive_time);p rintf("编号是:%d ",q->s_work.id);p rintf("服务时间是:%d\n",q->s_work.work_time);p rintf("完成时间是:%d ",w_finish_time[i+1]);p rintf("周转时间是:%d \n",w_rel_time[i+1]);}void showmenu(){printf("**********************************\n"); p rintf("请选择你要执行的命令~: \n");p rintf("1:先来先服务算法\n");p rintf("2:短作业优先算法\n");p rintf("3: 高响应比优先算法\n");p rintf("0: 退出菜单\n");p rintf("**********************************\n"); }void HRRN(){i nt w_rel_time[10];i nt w_finish_time[10];f loat rel_time = 0;f loat priority; //计算优先权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; //定义该链表有头结点,且第一个节点初始化为空f or(i=0;i<10;i++) //定义了十个进程{PNODE pNew = (PNODE)malloc(sizeof(NODE));if (NULL == pNew){printf("分配失败, 程序终止!\n");exit(-1);}pNew->s_work.id = rand()%100;pNew->s_work.arrive_time = rand()%10;pNew->s_work.work_time = rand()%10+1;pTail->pNext = pNew;pNew->pNext = NULL;pTail = pNew;}P NODE p = pHead->pNext; //p指向第一个节点w hile (NULL != p){printf("第%d个作业的编号是:%d\t",j+1,p->s_work.id);printf("第%d个作业到达时间:%d\t",j+1,p->s_work.arrive_time);printf("第%d个作业服务时间:%d\t",j+1,p->s_work.work_time);printf("\n");p = p->pNext;printf("\n");j++;}p = pHead->pNext;P NODE q = p; //p,q都指向第一个节点p = p->pNext;w hile(p != NULL){if(p->s_work.arrive_time < q->s_work.arrive_time) q = p;p = p->pNext;}P NODE r = pHead->pNext; //r也指向第一个节点i nt cnt = 0; //记录所有节点数据域中到达时间最短且相等的个数w hile(r!= NULL){if( r->s_work.arrive_time == q->s_work.arrive_time ) cnt++;r = r->pNext;}p = pHead->pNext;w hile(p != NULL) //在相等到达时间的作业中找服务时间最短的作业{if(cnt > 1){if( p->s_work.arrive_time ==q->s_work.arrive_time )if( p->s_work.work_time < q->s_work.work_time )q = p;p = p->pNext;}elsep =NULL;} //确定q所指作业最先到达且服务时间最短w_finish_time[0] = q->s_work.arrive_time +q->s_work.work_time;w_rel_time[0] = w_finish_time[0] -q->s_work.arrive_time;p rintf("第1个系统执行的作业到达时间:%d",q->s_work.arrive_time);p rintf("编号是:%d ",q->s_work.id);p rintf("服务时间是:%d \n",q->s_work.work_time); p rintf("完成时间是:%d ",w_finish_time[0]);p rintf("周转时间是:%d \n",w_rel_time[0]);p = pHead; //寻找q的前一个节点,方便删掉q节点w hile( p->pNext != q ){p = p->pNext;}p->pNext = q->pNext;f ree(q);q = NULL; //已经找到并执行第一个进程,执行完之后又将其删除了f or(i=0;i<9&&!Is_empty(pHead);i++){printf("现在系统还剩%d个作业!\n",cnt_work(pHead));do_work_1(pHead,w_finish_time,i);q = priorit(pHead);show(w_finish_time,i,q,w_rel_time);p = pHead; //寻找q的前一个节点,方便删掉q节点while( p->pNext != q ){p = p->pNext;}p->pNext = q->pNext;free(q);q = NULL;}f or(j=0;j<10;j++){rel_time += w_rel_time[j];}printf("平均周转时间:%f\n",rel_time/10);}void do_work_1(PNODE pHead,int *w_finish_time,int i) {P NODE p,q;i nt cnt = 0; //计数器清0,计算当前作业完成时,系统中有多少个作业已经到达p = pHead->pNext;q = p;w hile(p != NULL){if( p->s_work.arrive_time <= w_finish_time[i] ){cnt ++;q = p;p = p->pNext;}else{p = p->pNext;}} //q指向当前到达时间小于刚刚完成的作业,但有可能有另外几个进程也已经到达了,所以要进行下面的判断p rintf("系统中有%d个作业在当前作业完成时已经到达!\n",cnt);p = pHead->pNext;w hile(p != NULL){if(cnt>1) //说明此时有好几个都已经到达了{if(p->s_work.arrive_time <= w_finish_time[i]){p->s_work.wait = w_finish_time[i] -p->s_work.arrive_time;p = p->pNext;}else{p->s_work.wait = 0;p = p->pNext;}}else //当前作业完成时,没有作业到达的情况{p = p->pNext; //此时p指向第一个节点,q指向第二个节点,还是找最先到达的while( p != NULL ){if( p->s_work.arrive_time <q->s_work.arrive_time )q = p;p = p->pNext;}w_finish_time[i+1] = q->s_work.arrive_time +q->s_work.work_time;return;}}w_finish_time[i+1] = w_finish_time[i] +q->s_work.work_time;}PNODE priorit(PNODE pHead){P NODE p = pHead->pNext;w hile(p != NULL){if(p->s_work.wait > 0){p->s_work.priority = (p->s_work.wait +p->s_work.work_time) / p->s_work.work_time; //计算每一个已经等待的进程的优先等级p = p->pNext;}elsep = p->pNext;}p = pHead->pNext;P NODE q;q = p;p = p->pNext; //p已经指向第二个节点w hile(p != NULL){if(p->s_work.wait > 0){if(p->s_work.priority > q->s_work.priority){q = p;p = p->pNext;}elsep = p->pNext;}elsep = p->pNext;}p rintf("该进程优先级最高,为:%f\n",q->s_work.priority);return q;}实验结果:系统自动为每个算法模拟分配五个作业,同时随机生成作业的编号,作业的到达时间,作业估计运行的时间。

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

操作系统实验报告作业调度操作系统实验报告:作业调度引言:操作系统是计算机系统中最核心的软件之一,它负责管理计算机的资源,为用户提供良好的使用环境。

在操作系统中,作业调度是非常重要的一部分,它决定了计算机如何合理地分配和调度各个作业的执行顺序,以提高计算机的效率和性能。

本实验报告将介绍作业调度的概念、调度算法以及实验结果。

一、作业调度的概念作业调度是指根据一定的策略和算法,将就绪队列中的作业按照一定的顺序分配给处理器,使得计算机系统能够充分利用资源,提高系统的吞吐量和响应时间。

作业调度的目标是实现公平性、高效性和平衡性。

二、作业调度的算法1. 先来先服务(FCFS)调度算法FCFS调度算法是最简单的调度算法之一,它按照作业的到达顺序进行调度,先到达的作业先执行。

这种算法的优点是简单易实现,但是可能会导致长作业等待时间过长,造成资源浪费。

2. 最短作业优先(SJF)调度算法SJF调度算法是根据作业的执行时间来进行调度,执行时间短的作业先执行。

这种算法能够最大程度地减少平均等待时间,提高系统的响应速度,但是可能会导致长作业长时间等待。

3. 优先级调度算法优先级调度算法是根据作业的优先级来进行调度,优先级高的作业先执行。

这种算法可以根据不同的需求设置不同的优先级,但是可能会导致低优先级的作业长时间等待。

4. 时间片轮转调度算法时间片轮转调度算法是将处理器的执行时间划分为多个时间片,每个作业在一个时间片内执行,时间片用完后,将处理器分配给下一个作业。

这种算法可以实现公平性,但是可能会导致长作业等待时间过长。

三、实验结果与分析在本次实验中,我们使用了不同的作业调度算法,并对其进行了性能测试。

测试结果显示,FCFS算法在平均等待时间方面表现较差,而SJF算法和优先级调度算法在平均等待时间方面表现较好。

时间片轮转调度算法能够实现公平性,但是可能会导致长作业等待时间过长。

结论:作业调度是操作系统中的重要组成部分,合理的作业调度算法能够提高计算机系统的效率和性能。

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

作业调度
一、实验目的
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=gbk
workA={'作业名':'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=0
resultlist=[]
for work1 in list:
time+=work1['服务时间']
listdd=[]
ctime=0
for 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=0
resultlist=[]
for work1 in list:
time+=work1['服务时间']
listdd=[]
ctime=0
for 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=0
for work in resultlist:
work['结束时间']=work['服务时间']+time
time=work['结束时间']
work['周转时间']=work['结束时间']-work['到达时间']
work['带权周转时间']=work['周转时间'] / work['服务时间']
zzsj=0
dqzzsj=0
for 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),'响应比高者优先算法')。

相关文档
最新文档