操作系统作业调度实验

合集下载

操作系统作业调度算法实验

操作系统作业调度算法实验

操作系统作业调度算法实验
操作系统作业调度算法实验可以让你更深入地理解作业调度的概念和方法,以下是实验的基本步骤和内容:
一、实验目的
掌握作业调度的基本概念和算法原理。

理解不同作业调度算法的特点和优缺点。

通过实验验证作业调度算法的正确性和性能。

二、实验内容
实验准备:准备一台计算机或模拟器,安装操作系统,并准备好实验所需的作业。

实验步骤:
(1)编写作业描述文件,包括作业的名称、到达时间、所需资源等信息。

(2)实现先来先服务(FCFS)、最短作业优先(SJF)、最高响应比优先(HRN)等作业调度算法,并编写相应的调度程序。

(3)将作业按照一定的顺序输入到调度程序中,并记录每个作业的执行时间、等待时间等参数。

(4)根据记录的数据计算平均周转时间、平均带权周转时间等指标,分析不同调度算法的性能差异。

(5)根据实验结果,分析不同调度算法的优缺点,并给出改进建议。

实验报告:整理实验数据和结果,撰写实验报告,包括实验目的、实验内容、实验步骤、实验结果、分析和结论等部分。

三、实验注意事项
在实验过程中,要注意保证作业的公平性,避免某些作业一直得不到执行的情况发生。

在实验过程中,要注意观察和记录每个作业的执行时间和等待时间等参数,以便后续的分析和比较。

在实验过程中,要注意保证系统的稳定性和可靠性,避免出现意外情况导致实验结果不准确。

在实验过程中,要注意遵守实验室规定和操作规程,确保实验过程的安全和顺利进行。

操作系统进程调度算法模拟实验报告

操作系统进程调度算法模拟实验报告

操作系统进程调度算法模拟实验报告一、实验目的本实验旨在深入理解操作系统的进程调度算法,并通过模拟实验来探究不同调度算法之间的差异和优劣。

二、实验原理操作系统的进程调度算法是决定进程执行顺序的重要依据。

常见的调度算法有先来先服务(FCFS)、最短作业优先(SJF)、优先级调度(Priority Scheduling)、轮转法(Round Robin)和多级反馈队列调度(Multilevel Feedback Queue Scheduling)等。

1.先来先服务(FCFS)算法:按照进程到达的先后顺序进行调度,被调度的进程一直执行直到结束或主动阻塞。

2.最短作业优先(SJF)算法:按照进程需要的执行时间的短长程度进行调度,执行时间越短的进程越优先被调度。

3. 优先级调度(Priority Scheduling)算法:为每个进程分配一个优先级,按照优先级从高到低进行调度。

4. 轮转法(Round Robin)算法:将进程按照到达顺序排列成一个队列,每个进程被分配一个时间片(时间量度),当时间片结束时,将进程从队列头取出放置到队列尾。

5.多级反馈队列调度算法:将进程队列分为多个优先级队列,每个队列时间片大小依次递减。

当一个队列中的进程全部执行完毕或者发生阻塞时,将其转移到下一个优先级队列。

三、实验步骤与结果1.实验环境:- 操作系统:Windows 10- 编译器:gcc2.实验过程:(1)首先,设计一组测试数据,包括进程到达时间、需要的执行时间和优先级等参数。

(2)根据不同的调度算法编写相应的调度函数,实现对测试数据的调度操作。

(3)通过模拟实验,观察不同调度算法之间的区别,比较平均等待时间、完成时间和响应时间的差异。

(4)将实验过程和结果进行记录整理,撰写实验报告。

3.实验结果:这里列举了一组测试数据和不同调度算法的结果,以便对比分析:进程,到达时间,执行时间,优先------,----------,----------,-------P1,0,10,P2,1,1,P3,2,2,P4,3,1,P5,4,5,a.先来先服务(FCFS)算法:平均等待时间:3.8完成时间:15b.最短作业优先(SJF)算法:平均等待时间:1.6完成时间:11c. 优先级调度(Priority Scheduling)算法:平均等待时间:2.8完成时间:14d. 轮转法(Round Robin)算法:时间片大小:2平均等待时间:4.8完成时间:17e.多级反馈队列调度算法:第一级队列时间片大小:2第二级队列时间片大小:4平均等待时间:3.8完成时间:17四、实验总结通过上述的实验结果可以得出以下结论:1.在上述测试数据中,最短作业优先(SJF)算法的平均等待时间最短,说明该算法在短作业的情况下能够有效地减少等待时间。

操作系统——作业调度

操作系统——作业调度

操作系统——作业调度实验⼆作业调度模拟程序⼀、⽬的和要求 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.比较不同调度算法的优劣和特点;3.了解不同调度算法在不同场景下的应用。

二、实验环境和工具本实验使用C语言进行实现,可以选择任何一种编程环境和工具,例如Dev-C++、Visual Studio等。

三、实验过程及方法1.实现一个进程控制块(PCB)的数据结构,用来保存进程的相关信息,包括进程ID、进程状态、优先级等。

2.实现一个进程队列,用来保存就绪队列中的进程。

可以使用数组或链表等数据结构实现。

3. 实现不同调度算法的函数,包括先来先服务(FCFS)、最短作业优先(SJF)、优先级调度(Priority Scheduling)和时间片轮转(Round Robin)等。

4.根据实际需求生成一批进程,设置其信息,并根据不同算法进行调度。

5.对比不同算法的运行结果和性能,分析其优劣。

四、实验结果和分析通过实验,我们可以得到每个算法的平均等待时间、平均周转时间和吞吐量等性能指标。

根据这些指标,我们可以对不同算法进行评价和分析。

1.先来先服务(FCFS)算法FCFS算法是最简单的调度算法,按照进程到达的顺序进行调度。

它的主要优点是实现简单、公平性好。

然而,FCFS算法有明显的缺点,会导致长作业等待时间过长,产生"饥饿"现象。

2.最短作业优先(SJF)算法SJF算法是按照进程的执行时间长短进行调度的算法。

它能够最大限度地减少平均等待时间和周转时间,但是需要提前知道所有进程的执行时间,这在实际中是很难做到的。

操作系统实验_先来先服务的调度算法及短作业优先

操作系统实验_先来先服务的调度算法及短作业优先

操作系统实验_先来先服务的调度算法及短作业优先1.引言操作系统的调度算法是指在多进程环境中,操作系统为进程分配CPU 的顺序和策略。

先来先服务(FCFS)调度算法是最简单的调度算法之一,它按照进程到达的顺序为其分配CPU。

而短作业优先(SJF)调度算法是根据进程的执行时间来为其分配CPU,执行时间越短的进程越先执行。

本文将分别介绍FCFS调度算法和SJF调度算法,并对其进行评价和比较。

2.先来先服务(FCFS)调度算法2.1调度原理FCFS调度算法的原理非常简单,按照进程到达的顺序为其分配CPU。

当一个进程进入就绪队列后,如果CPU空闲,则立即为其分配CPU。

如果CPU正忙,则进程进入等待队列,等待CPU空闲后再分配。

在该算法中,进程的运行时间不考虑,只考虑进程到达的时间。

2.2优点与缺点FCFS调度算法的主要优点是实现简单,无需对进程的运行时间进行估计。

但FCFS算法存在一定的缺点。

首先,长作业在短作业前面等待的时间较长,可能导致长作业的响应时间过长。

其次,如果有一个进程出现阻塞或响应时间过长,其后面的进程也会受到影响,造成整个系统的性能下降。

3.短作业优先(SJF)调度算法3.1调度原理短作业优先(SJF)调度算法是根据进程的执行时间来为其分配CPU。

当一个进程进入就绪队列后,如果其执行时间比当前正在运行的进程短,则优先为该进程分配CPU。

如果当前没有运行的进程或者当前运行的进程执行完毕,则立即为该进程分配CPU。

在该算法中,进程的到达时间不考虑,只考虑进程的执行时间。

3.2优点与缺点SJF调度算法的主要优点是可以最大程度地减少平均等待时间,提高系统的吞吐量。

短作业可以快速执行完毕,从而让更多的作业得以执行。

但SJF算法存在一定的缺点。

首先,需要对进程的执行时间有一个准确的估计,对于实时系统或动态系统来说,估计执行时间可能会有一定的误差。

其次,在长作业激增的情况下,短作业可能会一直得不到CPU的分配,造成长时间的等待。

操作系统最高响应比优先调度算法实验报告

操作系统最高响应比优先调度算法实验报告

操作系统最高响应比优先调度算法实验报告一、实验目的1.了解操作系统中调度算法的概念和特点;2.掌握最高响应比优先调度算法的原理和实现;3.通过实验验证最高响应比优先调度算法在不同场景下的性能表现。

二、实验原理最高响应比优先调度算法是一种比较常见的作业调度算法,主要用于提高作业的响应速度和用户体验。

该算法的原则是根据作业的响应比来决定作业的调度顺序,响应比越高,优先级越高。

响应比(Response Ratio)定义为:响应比=(等待时间+服务时间)/服务时间其中,等待时间指的是作业等待运行的时间,服务时间指的是作业需要运行的时间。

在最高响应比优先调度算法中,每次从就绪队列中选择响应比最高的作业进行调度,直到所有作业都完成。

三、实验过程1.设计实验场景,包括作业数、服务时间和到达时间等参数;2.实现最高响应比优先调度算法的调度程序;3.根据参数设置,将作业按照到达时间的先后顺序放入就绪队列;4.按照最高响应比优先调度算法的原则,选择响应比最高的作业进行调度;5.更新作业的等待时间和响应比,并记录作业的调度顺序;6.统计作业的平均等待时间和平均响应时间,并输出结果。

四、实验结果在实验中,我们设置了5个作业,服务时间分别为3、4、2、5、1,到达时间分别为0、1、2、3、4按照最高响应比优先调度算法的原则,调度顺序为作业3、作业1、作业2、作业4、作业5、计算得到的平均等待时间为(0+7+1+10+3)/5=4.2,平均响应时间为(3+7+3+14+1)/5=5.6五、实验总结通过本次实验,我们了解了最高响应比优先调度算法的原理和实现过程。

该调度算法能够有效提高作业的响应速度和用户体验,但在实际应用中也存在一些问题,比如容易出现饥饿现象,即一些低响应比的作业可能一直得不到调度。

在选择调度算法时,需要根据实际情况和需求来进行权衡和选择,最高响应比优先调度算法适用于对响应时间要求较高的场景,但在其他场景下可能不适用。

操作系统实验_先来先服务的调度算法及短作业优先

操作系统实验_先来先服务的调度算法及短作业优先先来先服务调度算法是一种非抢占式的调度算法,它按照作业到达的先后顺序将作业分配给CPU。

具体来说,当一个作业进入就绪队列时,调度程序将把它放在队列的末尾,然后从队列的头部选择一个作业执行。

只有当一个作业执行完成后,作业队列的头部才会选择下一个作业执行。

先来先服务调度算法的优点是简单易实现,没有复杂的排序操作,适用于短作业和长作业混合的场景。

其缺点是没有考虑作业的执行时间,导致长作业会占用CPU很长时间,影响其他作业的响应时间。

短作业优先调度算法是一种抢占式的调度算法,它根据作业的执行时间选择优先级。

具体来说,当一个作业进入就绪队列时,调度程序会比较该作业的执行时间和其他就绪作业的执行时间,并选择执行时间最短的作业执行。

如果有一个新的作业到达,且其执行时间比当前执行的作业要短,那么调度程序会中断当前作业的执行并切换到新的作业执行。

短作业优先调度算法的优点是能够最大程度上减少作业的等待时间和响应时间,提高系统的吞吐量。

其缺点是需要对作业的执行时间有较准确的估计,否则可能导致长作业陷入饥饿状态。

此外,由于需要频繁进行作业的切换,短作业优先调度算法在实现上相对复杂。

在实际应用中,先来先服务调度算法适用于短作业和长作业混合的场景,或者作业的执行时间无法估计准确的情况下。

例如,在批处理系统中,作业的执行时间往往是固定的,先来先服务调度算法可以保证公平性,并且能够有效利用CPU资源。

而短作业优先调度算法适用于多任务环境下,作业的执行时间可以估计准确的情况下。

例如,在交互式系统中,用户的操作往往是短暂的,短作业优先调度算法可以最大限度地减少用户的等待时间,提高系统的响应速度。

总之,先来先服务调度算法和短作业优先调度算法是操作系统中常用的两种调度算法。

它们分别适用于不同的应用场景,在实际应用中可以根据具体需求选择不同的调度算法。

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

《操作系统》实验报告题目:作业调度算法班级:网络工程姓名:朱锦涛学号: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;}实验结果:系统自动为每个算法模拟分配五个作业,同时随机生成作业的编号,作业的到达时间,作业估计运行的时间。

操作系统进程调度实验报告

操作系统进程调度实验报告操作系统进程调度实验报告引言:操作系统是计算机系统中的核心软件之一,负责管理计算机的硬件资源并提供用户与计算机硬件之间的接口。

进程调度作为操作系统的重要功能之一,负责决定哪个进程可以获得处理器的使用权,以及进程如何在处理器上运行。

本实验旨在通过设计和实现一个简单的进程调度算法,加深对操作系统进程调度原理的理解。

一、实验目的本实验的主要目的是通过编写代码模拟操作系统的进程调度过程,掌握进程调度算法的实现方法,深入理解不同调度算法的特点和适用场景。

二、实验环境本实验使用C语言进行编程实现,可在Linux或Windows系统下进行。

三、实验内容1. 进程调度算法的选择在本实验中,我们选择了最简单的先来先服务(FCFS)调度算法作为实现对象。

FCFS算法按照进程到达的先后顺序进行调度,即先到先服务。

这种调度算法的优点是简单易实现,但缺点是无法适应不同进程的执行时间差异,可能导致长作业效应。

2. 进程调度的数据结构在实现进程调度算法时,我们需要定义进程的数据结构。

一个进程通常包含进程ID、到达时间、执行时间等信息。

我们可以使用结构体来表示一个进程,例如:```struct Process {int pid; // 进程IDint arrival_time; // 到达时间int burst_time; // 执行时间};```3. 进程调度算法的实现在FCFS调度算法中,我们需要按照进程到达的先后顺序进行调度。

具体实现时,可以使用一个队列来保存待调度的进程,并按照到达时间的先后顺序将进程入队。

然后,按照队列中的顺序依次执行进程,直到所有进程执行完毕。

4. 实验结果分析通过实现FCFS调度算法,我们可以观察到进程调度的过程和结果。

可以通过输出每个进程的执行顺序、等待时间和周转时间等指标来分析调度算法的效果。

通过比较不同调度算法的指标,可以得出不同算法的优缺点。

四、实验步骤1. 定义进程的数据结构,包括进程ID、到达时间和执行时间等信息。

(完整word版)操作系统作业调度实验报告-多道批处理

计算机学院计算机科学与技术专业07 班姓名学号教师评定_________________实验题目作业调度一、实验目的本实验要求学生模拟作业调度的实现,用高级语言编写和调试一个或多个作业调度的模拟程序,了解作业调度在操作系统中的作用,以加深对作业调度算法的理解。

二、实验内容和要求1、为单道批处理系统设计一个作业调度程序(1)、编写并调试一个单道处理系统的作业调度模拟程序。

(2)、作业调度算法:分别采用先来先服务(FCFS),最短作业优先(SJF)的调度算法。

(3)、由于在单道批处理系统中,作业一投入运行,它就占有计算机的一切资源直到作业完成为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所占用的CPU时限等因素。

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

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

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

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

2、模拟批处理多道操作系统的作业调度(1)写并调试一个作业调度模拟程序。

(2)作业调度算法:分别采用先来服务(FCFS)调度算法。

(3)在批处理系统中,要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求,所需要的资源是否得到满足。

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

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

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

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

实验二作业调度一、实验名称作业调度算法的模拟实现二、实验目标作业调度又称宏观调度,其主要任务是对磁盘设备上大量的后备作业,以一定的原则进行挑选,给选中的作业分配内存等必须的资源,建立其相应的进程,让其投入运行。

本实验要求学生用高级程序设计语言编写和调试一个简化的作业调度程序,模拟实现的调度算法包括:先来先服务调度算法,短作业优先调度算法,响应比高者优先调度算法等,并对这些算法的性能做比较和评价。

以加深学生对作业、作业调度以及作业调度的各种算法的理解。

三、实验环境要求Windows+Visual C++ 6.0;四、实验基本原理作业调度主要是完成作业从后备状态到执行状态的转变,以及从执行状态到完成状态的转变。

(1)创建JCB(作业控制块):系统在作业进入后备状态时为每个作业创建一个作业控制块(JCB),从而使该作业可被调度程序感知。

当该作业执行完毕进入完成状态时候,系统自动撤销其JCB并释放有关资源,进而撤销该作业。

(2)按照作业调度算法,从后备队列中挑选一作业投入运行。

作业调度程序为运行作业建立相应的进程,并分配资源。

(3)主要的作业调度算法包括:先来先服务(FCFS)、短作业优先和最高响应比。

(4)调度策略的指标:最常用的调度性能指标有,周转时间(带权)、吞吐率、响应时间以及设备利用率。

五、数据结构设计(1)作业控制块,包括作业的基本信息描述。

struct time //时间的数据结构{int hour;int minute;};struct Job //作业{string jobname; //作业名time intime; //进入时间int runtime; //作业估计运行时间time starttime; //作业开始时间time endtime; //作业结束时间int cycletime; //作业周转时间float cltime; //作业带权周转时间bool haverun; //是否已运行};六、流程图图1 作业调度算法流程图七、源代码#include <iostream>#include <string>using namespace std;struct time //时间的数据结构{int hour;int minute;};struct Job //作业{string jobname; //作业名time intime; //进入时间int runtime; //作业估计运行时间time starttime; //作业开始时间time endtime; //作业结束时间int cycletime; //作业周转时间float cltime; //作业带权周转时间bool haverun; //是否已运行};float T=0;//作业平均周转时间float W=0;//作业带权平均周转时间void showInput(Job job[],int &n) //输入提示{cout<<"**********请按作业进入时间先后顺序输入*********"<<endl;for(int i=0;i<n;i++){cout<<"作业"<<i+1<<":"<<endl;cout<<"作业名:";cin>>job[i].jobname;cout<<"作业进入时间:";scanf("%d:%d",&job[i].intime.hour,&job[i].intime.minute);cout<<"作业估计运行时间:";cin>>job[i].runtime;job[i].starttime.hour=0;job[i].starttime.minute=0;job[i].endtime.hour=0;job[i].endtime.minute=0;job[i].cycletime=0;job[i].cltime=0;job[i].haverun=false; //标记为未运行cout<<"*********************"<<endl;}}void Init(Job job[],int &n)//初始化{for(int i=0;i<n;i++){job[i].starttime.hour=0;job[i].starttime.minute=0;job[i].endtime.hour=0;job[i].endtime.minute=0;job[i].cycletime=0;job[i].cltime=0;job[i].haverun=false; //标记为未运行}T=0;W=0;}void showTime(time time) //显示时间{cout<<time.hour<<":"<<time.minute;}int timeDiff(time t1,time t2) //计算时间差,时间t1比t2大{return t1.hour*60+t1.minute-(t2.hour*60+t2.minute);}time timeAdd(time time,int addtime) //时间相加{time.hour+=addtime/60;time.minute+=addtime%60;if(time.minute>=60){time.hour++;time.minute-=60;}return time;}bool comtime(time t1,time t2)//比较两个时间的大小,第一个大就返回TRUE {if(t1.hour>t2.hour)return true;else if(t1.hour==t2.hour&&t1.minute>=t2.minute)return true;elsereturn false;}void showResult(Job job[],int &n) //显示结果{cout<<"jobname\tintime\truntime\tsttime\tendtime\t周转时间(分钟)\t带权周转时间"<<endl;cout<<"*********************************************************** ********"<<endl;for(int i=0;i<n;i++){cout<<job[i].jobname<<"\t";showTime(job[i].intime);cout<<"\t"<<job[i].runtime<<"\t";showTime(job[i].starttime);cout<<"\t";showTime(job[i].endtime);cout<<"\t "<<job[i].cycletime<<"\t\t "<<job[i].cltime<<endl;}cout<<"作业平均周转时间:T="<<T/(n*1.0)<<endl;cout<<"作业带权平均周转时间:W="<<W/(n*1.0)<<endl;}int minRuntime(Job job[],int &n,time &t) //找出作业中最短作业下标{int min=-1;for(int i=0;i<n;i++){if(job[i].haverun==false && comtime(t,job[i].intime)==true){min=i;break;}}for(int j=min+1;j<n;j++)if(job[j].haverun==false && job[j].runtime<job[min].runtime && comtime(t,job[j].intime)==true)min=j;return min;}void SJF(Job job[],int &n)//短作业优先作业调度{struct time t;job[0].starttime.hour=job[0].intime.hour;job[0].starttime.minute=job[0].intime.minute;job[0].endtime=timeAdd(job[0].starttime,job[0].runtime);job[0].haverun=true;job[0].cycletime=timeDiff(job[0].endtime,job[0].intime);job[0].cltime=job[0].cycletime*1.0/job[0].runtime;T+=job[0].cycletime;W+=job[0].cltime;t=job[0].endtime;while(minRuntime(job,n,t)!=-1){int i=minRuntime(job,n,t);if(comtime(job[i].intime,t))job[i].starttime=job[i].intime;elsejob[i].starttime=t;job[i].endtime=timeAdd(job[i].starttime,job[i].runtime);job[i].haverun=true;job[i].cycletime=timeDiff(job[i].endtime,job[i].intime);job[i].cltime=job[i].cycletime*1.0/job[i].runtime;T+=job[i].cycletime;W+=job[i].cltime;t=job[i].endtime;}}int Firstintime(Job job[],int &n) //找出作业中最先到的{int min=-1;for(int i=0;i<n;i++){if(job[i].haverun==false){min=i;break;}}for(int j=min+1;j<n;j++)if(job[j].haverun==false && comtime(job[min].intime,job[j].intime)) min=j;return min;}void FCFS(Job job[],int &n)//先来先服务作业调度{struct time t;job[0].starttime.hour=job[0].intime.hour;job[0].starttime.minute=job[0].intime.minute;job[0].endtime=timeAdd(job[0].starttime,job[0].runtime);job[0].haverun=true;job[0].cycletime=timeDiff(job[0].endtime,job[0].intime);job[0].cltime=job[0].cycletime*1.0/job[0].runtime;T+=job[0].cycletime;W+=job[0].cltime;t=job[0].endtime;while(Firstintime(job,n)!=-1){int i=Firstintime(job,n);if(comtime(job[i].intime,t))job[i].starttime=job[i].intime;elsejob[i].starttime=t;job[i].endtime=timeAdd(job[i].starttime,job[i].runtime);job[i].haverun=true;job[i].cycletime=timeDiff(job[i].endtime,job[i].intime);job[i].cltime=job[i].cycletime*1.0/job[i].runtime;T+=job[i].cycletime;W+=job[i].cltime;t=job[i].endtime;}}void main(){cout<<"请输入作业数:";int n; //作业数cin>>n;Job *job=new Job[n];if(n<=0){cout<<"输入不合法!";exit(-1);}else{showInput(job,n);cout<<endl;FCFS(job,n);cout<<"先来先服务:"<<endl;showResult(job,n);cout<<endl;Init(job,n);SJF(job,n); //短作业优先cout<<"短作业优先:"<<endl;showResult(job,n);}system("pause");}八、运行结果用户输入作业的相关信息,程序输出相应的各种算法运行结果。

相关文档
最新文档