作业调度先来先服务实验剖析
作业调度算法-实验报告
作业调度算法-实验报告作业调度算法模拟一、课题内容和要求常见的作业调度算法有先来先服务算法、最短作业优先算法、响应比优先调度算法。
(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. 引言进程调度是操作系统中非常重要的一部分,它决定了进程在CPU上执行的顺序和时间长度。
在本次实验中,我们通过实现先来先服务调度算法、时间片调度算法和优先级调度算法,并对其性能进行比较,来深入了解各种调度算法的工作原理及优缺点。
2. 先来先服务调度算法先来先服务调度算法按照进程到达的先后顺序进行调度。
当一个进程到达时,如果CPU空闲,则将其分配给CPU进行执行;如果CPU 正在执行其他进程,则该进程将等待直到CPU空闲。
优点是简单易实现,适用于长作业。
缺点是可能出现饥饿现象,即低优先级的进程可能会一直等待高优先级进程的执行。
3. 时间片调度算法时间片调度算法将CPU的执行时间划分为固定长度的时间片,每个进程在一个时间片内执行,当时间片用完后,系统将切换到下一个进程执行。
该算法确保每个进程都有公平的执行时间,避免了饥饿现象。
然而,对于CPU利用率较高的情况下,可能会导致进程频繁地切换,增加了上下文切换的开销。
4. 优先级调度算法优先级调度算法根据进程的优先级来进行调度,优先级较高的进程将具有更高的执行优先级。
当多个进程同时到达CPU时,系统将选择优先级最高的进程先执行。
该算法可以分为静态优先级调度和动态优先级调度两种方式。
优点是可以根据进程的重要性灵活调整执行顺序。
缺点是可能导致优先级低的进程长时间等待,造成饥饿现象。
5. 实验结果与分析我们通过模拟多个进程的到达和执行过程,在不同的场景下比较了先来先服务调度算法、时间片调度算法和优先级调度算法的性能。
实验结果显示,在长作业的情况下,先来先服务调度算法表现较好;在要求公平性的场景下,时间片调度算法比较适合;而对于需要根据优先级来调度的场景,优先级调度算法可以更好地满足需求。
6. 结论不同的进程调度算法在不同的场景下有各自的优劣。
先来先服务调度算法简单易实现,适用于长作业;时间片调度算法保证了公平性,适用于要求公平的场景;而优先级调度算法则可以根据进程的重要性进行调度。
先来先服务调度和最短作业优先调度算法实验报告
实验报告说明
1.实验项目名称:要用最简练的语言反映实验的内容。
要求与实验指导书中相一致。
2.实验类型:一般需说明是验证型实验还是设计型实验,是创新型实验还是综合型实验。
3.实验目的与要求:目的要明确,要抓住重点,符合实验指导书中的要求。
4.实验原理:简要说明本实验项目所涉及的理论知识。
5.实验环境:实验用的软硬件环境(配置)。
6.实验方案设计(思路、步骤和方法等):这是实验报告极其重要的内容。
概括整个实验过程。
对于操作型实验,要写明依据何种原理、操作方法进行实验,要写明需要经过哪几个步骤来实现其操作。
对于设计型和综合型实验,在上述内容基础上还应该画出流程图、设计思路和设计方法,再配以相应的文字说明。
对于创新型实验,还应注明其创新点、特色。
7.实验过程(实验中涉及的记录、数据、分析):写明具体上述实验方案的具体实施,包括实验过程中的记录、数据和相应的分析。
8.结论(结果):即根据实验过程中所见到的现象和测得的数据,做出结论。
9.小结:对本次实验的心得体会、思考和建议。
10.指导教师评语及成绩:指导教师依据学生的实际报告内容,用简练语言给出本次实验报告的评价和价值。
注意:
实验报告将记入实验成绩;
每次实验开始时,交上一次的实验报告,否则将扣除此次实验成绩。
先来先服务实验报告
先来先服务调度算法一,实验目的1.加深对先来先服务算法的理解。
2.利用C语言编写算法,模拟实现先来先服务算法。
3.模拟先来先服务算法,并计算平均周转时间和平均带权周转时间。
二,实验开发平台。
Microsoft Visual C++6.0三,调度算法说明先来先服务调度算法,是一种简单的调度算法,该算法即可用于作业调度,也可用于进程调度,就是每次从就绪队列中选择一个最先进入队列的进程,该算法比较有利于长作业,而不利于短作业。
另外,FCFS调度算法对CPU繁忙型作业比较有利,而不利于I/O繁忙作业。
四,实验源程序。
#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0struct jcb {char name[10];char state;/*状态*/int atime; /*到达时刻*/int ntime; /*所需时间*/int ctime; /*完成时刻*/int stime; /*开始时刻*/int ttime; /*周转时间*/float bttime;/*带权周转时间*/struct jcb* link;}*ready=NULL,*p,*q;typedef struct jcb JCB;float wtime=0,wttime=0,wbttime=0;sort(){ if(ready==NULL){p->link=ready;ready=p;q=p;}else{ q->link=p;q=p;}}input(){ int i,num;printf("\n 请输入作业数:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n 作业号No.%d:\n",i);p=getpch(JCB);printf("\n 输入作业名:");scanf("%s",p->name);printf("\n 输入作业所需时间:");scanf("%d",&p->ntime);printf("\n");p->atime=i;p->state='w';p->link=NULL;sort(); /* 调用sort函数*/}}int space(){int l=0; JCB* pr=ready;while(pr!=NULL){l++;pr=pr->link;}return(l);}disp1(JCB* pr) /*建立作业显示函数,用于显示当前作业*/{printf("\n作业名|状态|开始时刻|完成时刻|周转时间|带权周转时间\n"); printf("%s\t",pr->name);printf("%c\t",pr->state);printf("%d\t",pr->stime);printf("%d\t",pr->ctime);printf("%d\t",pr->ttime);printf("%f\t",pr->bttime);printf("\n");}disp2(JCB* pr) /*建立进程显示函数,用于显示当前进程*/{printf("\n作业名|状态|到达时刻|所需时间\n");printf("%s\t",pr->name);printf("%c\t",pr->state);printf("%d\t",pr->atime);printf("%d\t",pr->ntime);printf("\n");}check() /* 建立作业查看函数*/{JCB* pr;pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){disp2(pr);pr=pr->link;}}destroy() /*建立作业撤消函数(作业运行结束,撤消作业)*/{printf("\n 作业[%s] 已完成.\n",p->name);free(p);}running(){p->stime=wtime;p->ctime=p->stime+p->ntime;p->ttime=p->ctime-p->atime;p->bttime=(float)p->ttime/(float)p->ntime;wtime=wtime+p->ntime;/*printf("时间:%f",wtime);*/wttime=wttime+p->ttime;wbttime=wbttime+p->bttime;printf("\n **** 当前正在运行的作业是:%s",p->name); /*显示当前运行作业*/ disp1(p);destroy();}main() /*主函数*/{int len,h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ch=getchar();h++;printf("\n The execute number:%d \n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';running();check();printf("\n 按任一键继续......");ch=getchar();}printf("\n\n 作业已经完成.\n");printf("\n该次作业调度平均周转时间:%f\n",wttime/len); printf("\n该次作业调度带权平均周转时间:%f\n",wbttime/len); ch=getchar();}五,实验结果。
调度的调度算法实验报告
调度的调度算法实验报告调度的调度算法实验报告引言:调度是计算机科学中一个重要的概念,它涉及到任务分配、资源管理和优化等方面。
调度算法则是实现调度的关键,它决定了任务的执行顺序和资源的分配方式。
在本次实验中,我们将探讨几种常见的调度算法,并通过实验对其性能进行评估和比较。
一、先来先服务算法(FCFS)先来先服务算法是最简单的调度算法之一,它按照任务到达的先后顺序进行处理。
实验中,我们模拟了一个任务队列,每个任务有不同的执行时间。
通过实验结果可以看出,FCFS算法的优点是简单易懂,但当任务的执行时间差异较大时,会导致平均等待时间较长。
二、最短作业优先算法(SJF)最短作业优先算法是一种非抢占式调度算法,它根据任务的执行时间来进行排序。
实验中,我们将任务按照执行时间从短到长进行排序,并进行调度。
实验结果显示,SJF算法的优点是能够最大程度地减少平均等待时间,但当任务的执行时间无法预测时,该算法可能会导致长任务等待时间过长的问题。
三、时间片轮转算法(RR)时间片轮转算法是一种抢占式调度算法,它将任务分为多个时间片,并按照顺序进行调度。
实验中,我们设置了每个时间片的长度,并将任务按照到达顺序进行调度。
实验结果表明,RR算法的优点是能够公平地分配资源,但当任务的执行时间超过一个时间片时,会导致上下文切换频繁,影响系统的性能。
四、最高响应比优先算法(HRRN)最高响应比优先算法是一种动态调度算法,它根据任务的等待时间和执行时间来计算响应比,并选择响应比最高的任务进行调度。
实验中,我们根据任务的到达时间、执行时间和等待时间计算响应比,并进行调度。
实验结果显示,HRRN算法能够在一定程度上平衡长任务和短任务的等待时间,但当任务的执行时间过长时,会导致其他任务的等待时间过长。
五、多级反馈队列算法(MFQ)多级反馈队列算法是一种综合性的调度算法,它将任务分为多个队列,并根据任务的执行情况进行调度。
实验中,我们设置了多个队列,并根据任务的执行时间和等待时间进行调度。
先来先服务调度和最短作业优先调度算法实验报告
先来先服务调度和最短作业优先调度算法实验报告实验报告一、实验目的本实验旨在通过编写代码实现先来先服务调度算法和最短作业优先调度算法,以深入理解和掌握这两种调度算法的原理和实现方法。
二、实验方法和原理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:```运行以上代码,会得到相应的作业调度结果。
先来先服务FCFS和短作业优先SJF进程调度算法
先来先服务FCFS和短作业优先SJF进程调度算法1、实验目的通过这次实验,加深对进程概念的理解,进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。
2、需求分析(1) 输入的形式和输入值的范围输入值:进程个数Num 范围:0<Num<=100依次输入Num个进程的到达时刻范围:依次输入Num个进程的服务时刻范围:输入要使用的算法(1-FCFS,2-SJF)范围:1或者2(2) 输出的形式(X表示变量)时刻X:进程X开始运行。
其完成时刻:X 周转时刻:X 带权周转时刻:X…(省略(Num-1)个)平均周转时刻:X平均带权周转时刻:X(3) 程序所能达到的功能输入进程个数Num,每个进程到达时刻ArrivalTime[i],服务时刻ServiceTime[i]。
采纳先来先服务FCFS或者短作业优先SJF进程调度算法进行调度,计算每个进程的完成时刻、周转时刻和带权周转时刻,同时统计Num个进程的平均周转时刻和平均带权周转时刻。
3、概要设计讲明本程序中用到的所有抽象数据类型的定义、主程序的流程以及各程序模块之间的层次(调用)关系。
4、详细设计5、调试分析(1)调试过程中遇到的问题以及解决方法,设计与实现的回忆讨论和分析○1开始的时候没有推断进程是否到达,导致短进程优先算法运行结果错误,后来加上了推断语句后就解决了改问题。
○2差不多完成的设计所要实现的功能,总的来讲,FCFS编写容易,SJF需要先找到差不多到达的进程,再从差不多到达的进程里找到进程服务时刻最短的进程,再进行计算。
(2)算法的改进设想改进:即使用户输入的进程到达时刻没有先后顺序也能准确的计算出结果。
(确实是再加个循环,推断各个进程的到达时刻先后,组成一个有序的序列)(3)经验和体会通过本次实验,深入理解了先来先服务和短进程优先进程调度算法的思想,培养了自己的动手能力,通过实践加深了经历。
6、用户使用讲明(1)输入进程个数Num(2)依次输入Num个进程的到达时刻(3)依次输入Num个进程的服务时刻(4)选择要使用的算法7、测试结果正确一(FCFS):正确一(SJF):正确二(FCFS):正确二(SJF):错误(进程个数错误):错误(选择算法错误):8、附录//***************************************************** **************//** 进程调度算法 BY:09软件工程二班李群**//***************************************************** **************#include<iostream>#include<iomanip>using namespace std;static const int Max=100;int ArrivalTime[Max];//到达时刻int ServiceTime[Max];//服务时刻int FinishTime[Max];//完成时刻int WholeTime[Max];//周转时刻double WeightWholeTime[Max];//帯权周庄时刻double AverageWT_FCFS,AverageWT_SJF; //平均周转时刻double AverageWWT_FCFS,AverageWWT_SJF;//平均帯权周转时刻int ServiceTime_SJF[Max];//在SJF算法中使用到int Num=0;int NowTime=0;//记录当前时刻double SumWT=0,SumWWT=0;//SumWT用来计算总的周转时刻,SumWWT用来计算总的帯权周转时刻int i;int choice;//记录选择//***************************************************** *************// 先到先服务算法//***************************************************** *************void FCFS()//找最早到达的。
作业调度实验报告
作业调度实验报告一、实验目的本次作业调度实验的主要目的是深入理解和掌握作业调度的基本原理和算法,通过实际编程和模拟实验,分析不同调度策略对系统性能的影响,从而为优化作业调度提供理论依据和实践经验。
二、实验环境本次实验在 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)优先级调度算法根据作业的优先级来安排执行顺序。
操作系统实验_先来先服务的调度算法及短作业优先
操作系统实验_先来先服务的调度算法及短作业优先先来先服务调度算法是一种非抢占式的调度算法,它按照作业到达的先后顺序将作业分配给CPU。
具体来说,当一个作业进入就绪队列时,调度程序将把它放在队列的末尾,然后从队列的头部选择一个作业执行。
只有当一个作业执行完成后,作业队列的头部才会选择下一个作业执行。
先来先服务调度算法的优点是简单易实现,没有复杂的排序操作,适用于短作业和长作业混合的场景。
其缺点是没有考虑作业的执行时间,导致长作业会占用CPU很长时间,影响其他作业的响应时间。
短作业优先调度算法是一种抢占式的调度算法,它根据作业的执行时间选择优先级。
具体来说,当一个作业进入就绪队列时,调度程序会比较该作业的执行时间和其他就绪作业的执行时间,并选择执行时间最短的作业执行。
如果有一个新的作业到达,且其执行时间比当前执行的作业要短,那么调度程序会中断当前作业的执行并切换到新的作业执行。
短作业优先调度算法的优点是能够最大程度上减少作业的等待时间和响应时间,提高系统的吞吐量。
其缺点是需要对作业的执行时间有较准确的估计,否则可能导致长作业陷入饥饿状态。
此外,由于需要频繁进行作业的切换,短作业优先调度算法在实现上相对复杂。
在实际应用中,先来先服务调度算法适用于短作业和长作业混合的场景,或者作业的执行时间无法估计准确的情况下。
例如,在批处理系统中,作业的执行时间往往是固定的,先来先服务调度算法可以保证公平性,并且能够有效利用CPU资源。
而短作业优先调度算法适用于多任务环境下,作业的执行时间可以估计准确的情况下。
例如,在交互式系统中,用户的操作往往是短暂的,短作业优先调度算法可以最大限度地减少用户的等待时间,提高系统的响应速度。
总之,先来先服务调度算法和短作业优先调度算法是操作系统中常用的两种调度算法。
它们分别适用于不同的应用场景,在实际应用中可以根据具体需求选择不同的调度算法。
先来先服务调度算法 实验四分析报告
操作系统实验四设计先来先服务进程调度模拟算法实验提示:进程个数至少5个以上(动态),也可让用户动态输入,每个进程由一个进程控制块来标识,进程控制块的内容根据情况自己设计,但至少要有进程名、进程状态、到达时间、估计运行时间信息;设计一个先进先出队列和系统时间,调度时,总是选择队列头部(到达时间最早)的进程;当进程到达时间小于系统时间时,进程执行,当在当前时间没有到达的进程时,可安排延时来模拟闲逛进程。
由于本实验为模拟实验,所以被选中调度进程并不实际启动运行,而仅执行按估计运行时间延时,并输出进程的开始和结束运行信息模拟进程的运行,而且省去进程的现场保护和现场恢复工作。
在所设计的程序中应有显示或打印语句,能显示或打印就绪队列中的进程、正运行进程的进程名、开始运行时间、结束运行时间等,给出各进程的周转时间和平均周转时间。
实验要求:实验报告中要给出流程图和源程序,源程序中要附有详细的注释,给出程序运行时的输入值和运行结果总结收获或对该题的改进意见和见解。
流程图:源程序:输入值:ID 进程名到达时间服务时间1 A2 32 B3 43 C4 5运行结果:总结收获:通过本次实验,我了解到如果早就绪的进程排在就绪队列的前面,迟就绪的进程排在就绪队列的后面,那么先来先服务总是把当前处于就绪队列之首的那个进程调度到运行状态。
也就说,它只考虑进程进入就绪队列的先后,而不考虑它的下一个CPU周期的长短及其他因素。
FCFS算法简单易行,是一种非抢占式策略,但性能却不大好。
先来先服务的调度算法:最简单的调度算法,既可以用于作业调度,也可以用于程序调度,当作业调度中采用该算法时,系统将按照作业到达的先后次序来进行调度,优先从后备队列中,选择一个或多个位于队列头部的作业,把他们调入内存,分配所需资源、创建进程,然后放入“就绪队列”,直到该进程运行到完成或发生某事件堵塞后,进程调度程序才将处理机分配给其他进程。
有利于长作业(进程)而不利于短作业(进程)和CPU 繁忙型作业(进程)而不利于I/O繁忙型作业(进程)。
作业调度算法(先来先服务算法,短作业算法)
《操作系统》实验报告题目:作业调度算法班级:网络工程姓名:朱锦涛学号: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),最短作业优先(SJF)、响应比高者优先(HRN)的调度算法。
(1)先来先服务算法:按照作业提交给系统的先后顺序来挑选作业,先提交的先被挑选。
(2)最短作业优先算法:是以进入系统的作业所提出的“执行时间”为标准,总是优先选取执行时间最短的作业。
(3)响应比高者优先算法:是在每次调度前都要计算所有被选作业(在后备队列中)的响应比,然后选择响应比最高的作业执行。
2、编写并调度一个多道程序系统的作业调度模拟程序。
作业调度算法:采用基于先来先服务的调度算法。
可以参考课本中的方法进行设计。
对于多道程序系统,要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。
二.实验目的:本实验要求用高级语言(C语言实验环境)编写和调试一个或多个作业调度的模拟程序,了解作业调度在操作系统中的作用,以加深对作业调度算法的理解三 .实验过程<一>单道处理系统作业调度1)单道处理程序作业调度实验的源程序: zuoye.c执行程序: zuoye.exe2)实验分析:1、由于在单道批处理系统中,作业一投入运行,它就占有计算机的一切资源直到作业完成为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所占用的 CPU 时限等因素。
2、每个作业由一个作业控制块JCB 表示,JCB 可以包含如下信息:作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。
作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。
每个作业的最初状态总是等待W 。
3、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间,以及这组作业的平均周转时间及带权平均周转时间。
3)流程图:二.最短作业优先算法三.高响应比算法图一.先来先服务流程图4)源程序:#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\t\t\t计算机学院软件四班\n");printf("\t\t\t\t\t蓝小花\n");printf("\t\t\t\t\t完成日期:2006年11月17号");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);getch();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);getch();}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);getch();}}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)/p adv->needtimepadv=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(); //调用running()函数}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(); //调用running()函数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(); //调用running()函数}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();}}main() //主函数{inize();mune();}5)调试结果:1.选择操作的界面2.输入操作初始信息:3.先来先服务算法作业调度结果: (调度顺序:a->b->c->d->e)4.最短作业优先算法作业调度结果(调度顺序: a->d->b->e->c)5.高响应比算法作业调度结果: (调度顺序 a->b->d->c->e)<二>多道处理系统作业调度1)多道处理程序作业调度实验的源程序: duodao.c执行程序: duodao.exe2)实验分析:采用多道程序设计方法的操作系统,在系统中要经常保留多个运行的作业,以提高系统效率。
先来先服务FCFS和短作业优先SJF进程调度算法_实验报告材料
先来先服务FCFS和短作业优先SJF进程调度算法_实验报告材料一、实验目的本实验的目的是通过编写程序模拟先来先服务(FCFS)和短作业优先(SJF)进程调度算法,并对其效果进行评估,从而对两种算法有一个更直观的认识。
二、实验原理2. 短作业优先(Shortest-Job-First, SJF)进程调度算法:根据进程的执行时间进行调度,选择执行时间最短的进程先执行。
三、实验步骤1. 设计进程类Process,包含进程名称、到达时间、执行时间等属性,并重载比较运算符以便后续排序。
2. 设计FCFS调度算法函数fcfs_scheduling,实现进程按照先来先服务的规则进行调度。
3. 设计SJF调度算法函数sjf_scheduling,实现进程按照执行时间最短的规则进行调度。
4. 编写主函数,分别调用fcfs_scheduling和sjf_scheduling函数,并根据实际情况输出结果,比较两种算法的效果。
四、实验结果与分析1.输入样例:进程A:到达时间0,执行时间3进程B:到达时间1,执行时间4进程C:到达时间2,执行时间2进程D:到达时间4,执行时间12.输出结果:FCFS调度结果:A->B->C->D,平均等待时间为(0+3+7+9)/4=4.75SJF调度结果:A->C->B->D,平均等待时间为(0+1+3+6)/4=2.53.结果分析:从结果可以看出,短作业优先(SJF)进程调度算法能够更好地减少进程的等待时间,因为它根据进程的执行时间进行调度,优先执行执行时间较短的进程。
与之相比,先来先服务(FCFS)进程调度算法无法对不同进程的执行时间进行判断,可能导致执行时间较短的进程等待时间长。
五、实验总结通过本次实验,我对先来先服务(FCFS)和短作业优先(SJF)进程调度算法有了更深入的了解。
先来先服务(FCFS)算法简单直观,但无法保证最优解;短作业优先(SJF)算法可以减少进程的等待时间,但需要预知每个进程的执行时间。
调度算法实验报告总结(3篇)
第1篇一、实验目的本次实验旨在通过模拟操作系统中的进程调度过程,加深对进程调度算法的理解。
实验中,我们重点研究了先来先服务(FCFS)、时间片轮转(RR)和动态优先级调度(DP)三种常见的调度算法。
通过编写C语言程序模拟这些算法的运行,我们能够直观地观察到不同调度策略对进程调度效果的影响。
二、实验内容1. 数据结构设计在实验中,我们定义了进程控制块(PCB)作为进程的抽象表示。
PCB包含以下信息:- 进程编号- 到达时间- 运行时间- 优先级- 状态(就绪、运行、阻塞、完成)为了方便调度,我们使用链表来存储就绪队列,以便于按照不同的调度策略进行操作。
2. 算法实现与模拟(1)先来先服务(FCFS)调度算法FCFS算法按照进程到达就绪队列的顺序进行调度。
在模拟过程中,我们首先将所有进程按照到达时间排序,然后依次将它们从就绪队列中取出并分配CPU资源。
(2)时间片轮转(RR)调度算法RR算法将CPU时间划分为固定的时间片,并按照进程到达就绪队列的顺序轮流分配CPU资源。
当一个进程的时间片用完时,它将被放入就绪队列的末尾,等待下一次调度。
(3)动态优先级调度(DP)算法DP算法根据进程的优先级进行调度。
在模拟过程中,我们为每个进程分配一个优先级,并按照优先级从高到低的顺序进行调度。
3. 输出调度结果在模拟结束后,我们输出每个进程的调度结果,包括:- 进程编号- 到达时间- 运行时间- 等待时间- 周转时间同时,我们还计算了平均周转时间、平均等待时间和平均带权周转时间等性能指标。
三、实验结果与分析1. FCFS调度算法FCFS算法简单易实现,但可能会导致进程的响应时间较长,尤其是在存在大量短作业的情况下。
此外,FCFS算法可能导致某些进程长时间得不到调度,造成饥饿现象。
2. 时间片轮转(RR)调度算法RR算法能够有效地降低进程的响应时间,并提高系统的吞吐量。
然而,RR算法在进程数量较多时,可能会导致调度开销较大。
操作系统实验_先来先服务的调度算法和短作业优先
操作系统实验_先来先服务的调度算法和短作业优先先来先服务(FCFS)调度算法是一种非抢占式调度算法,在这种算法中,进程按照到达系统的先后顺序执行,并且在一个进程执行完毕之前,不会有其他进程执行。
如果一个进程没有执行完成,后续进程需要等待。
FCFS调度算法的优点是实现简单,公平性好。
由于按照到达时间先后顺序执行进程,能够保证所有进程都能够得到执行的机会。
然而,FCFS调度算法容易出现“饥饿”现象,即如果一个进程占用了较长的CPU时间,其他进程可能需要等待较长时间。
短作业优先(SJF)调度算法是一种非抢占式调度算法,它选择下一个执行的进程是根据预计的执行时间最短的进程。
在SJF调度算法中,进程按照预计的执行时间进行排序,并按照顺序执行。
SJF调度算法的优点是能够最大程度地减少平均等待时间。
因为进程按照预计的执行时间最短的顺序执行,执行时间短的进程优先执行,可以最大限度地减少其他进程等待的时间。
然而,SJF调度算法需要预先知道所有进程的执行时间,并且如果一个进程执行时间长,其他进程需要等待的时间可能会很长。
FCFS调度算法和SJF调度算法都有各自的优点和局限性。
FCFS调度算法适用于进程执行时间相对均匀的情况,可以保证所有进程都能够得到执行的机会。
但是,如果一个进程执行时间很长,可能会导致其他进程等待的时间非常长,容易出现“饥饿”现象。
SJF调度算法适用于进程执行时间差异较大的情况,可以最大程度地减少平均等待时间。
但是,SJF调度算法需要预先知道所有进程的执行时间,而且在实际应用中,很难准确预测进程的执行时间。
在实验中,可以通过编写相应的模拟程序来实现FCFS调度算法和SJF调度算法。
可以设定一个进程队列,每个进程有自己的到达时间和执行时间。
按照FCFS算法,按照到达时间先后顺序执行进程;按照SJF算法,按照执行时间从小到大的顺序执行进程。
通过模拟进程的调度过程,可以观察到FCFS算法和SJF算法的效果差异。
操作系统实验报告作业调度
操作系统实验报告:作业调度1. 引言作业调度是操作系统中的一个重要概念,它涉及到如何合理地安排计算机系统中的作业执行顺序,以最大程度地提高系统的效率和性能。
本文将介绍作业调度的基本概念和主要算法,以及在实验中的应用。
2. 作业调度的概念作业调度是指根据一定的策略和算法,按照一定的顺序从作业队列中选取作业,将其分配给可用资源来执行的过程。
作业调度的目标是实现公平、高效的任务分配,以提高系统的整体性能。
3. 作业调度算法3.1 先来先服务(FCFS)先来先服务是最简单的作业调度算法,即按照作业提交的顺序来执行。
当一份作业到达系统后,它将被放入作业队列的末尾。
一旦当前执行的作业完成,系统将选择队列中的下一个作业来执行。
3.2 短作业优先(SJF)短作业优先算法是根据作业的执行时间来进行调度,执行时间越短的作业优先级越高。
当一个作业进入系统时,系统会检查队列中的所有作业,并选择执行时间最短的作业来执行。
3.3 优先级调度优先级调度算法是根据作业的优先级来进行调度,优先级越高的作业优先级越高。
每个作业都会被分配一个优先级值,系统会按照优先级从高到低的顺序来执行作业。
3.4 时间片轮转调度时间片轮转调度算法将作业分为多个时间片,每个时间片的执行时间相等。
当一个作业进入系统时,系统会分配给它一个时间片,如果在时间片内作业没有完成,则将其放回队列的末尾,并执行下一个作业。
4. 实验中的应用在操作系统实验中,作业调度是一个重要的实验内容。
通过实验,我们可以深入了解不同调度算法的特点和适用场景。
实验中,我们可以使用模拟器来模拟作业调度的过程。
我们可以创建一个作业队列,然后使用不同的调度算法来执行这些作业,并记录它们的执行时间和系统的吞吐量。
通过实验,我们可以比较不同算法在不同场景下的表现,选择最适合当前系统的作业调度算法。
5. 结论作业调度是一个重要的操作系统概念,它决定了系统的性能和效率。
在本文中,我们介绍了作业调度的基本概念和常用算法,并讨论了在实验中的应用。
操作系统实验_先来先服务的调度算法和短作业优先
操作系统实验_先来先服务的调度算法和短作业优先操作系统中的进程调度算法是实现多道程序设计的关键,作为操作系统中的调度器,它决定了进程在CPU上执行的顺序,直接影响到系统的性能和响应时间。
本文将重点介绍两种常用的进程调度算法:先来先服务调度算法(FCFS)和短作业优先调度算法(SJF)。
先来先服务调度算法是一种最简单、最基础的调度算法,其实现非常简单:按照进程到达CPU的先后顺序,将其依次调入CPU执行。
当一个进程进入就绪队列后,在CPU空闲的时候,就将其调入CPU执行,直到进程执行完成或者主动放弃CPU时间片。
这种调度算法的优势在于实现简单、公平性好;但其缺点也很明显,由于没有考虑进程的执行时间长短,如果一个长时间的进程先到达就绪队列,则会造成其他进程的等待时间过长,导致系统的响应时间较长。
与FCFS相对的是短作业优先调度算法(Shortest Job First, SJF)。
SJF调度算法会根据进程的相对执行时间长短来进行调度,即将执行时间最短的进程优先调度进入CPU执行。
SJF算法的关键在于如何估计进程的执行时间,通常有两种方法:预测和历史信息。
预测方法是根据进程的相关信息,如进程的大小、执行时间等进行预测;而历史信息方法是根据以往同类任务的执行时间的平均值或历史执行时间进行估算。
在实际操作中,通常采用后者进行调度。
SJF调度算法的优势在于可以最大程度地减少平均等待时间,提高系统的响应效率。
然而,该算法也存在一些问题,如如何准确估算进程的执行时间、对长时间任务不够友好等。
两种调度算法各自都有其优势和劣势,因此在实际操作中需要根据具体的情况选择适用的调度算法。
如果系统中存在大量长时间任务,可以考虑使用FCFS来保证公平性;而如果系统中的任务短且繁琐,可以优先考虑SJF算法来减少平均等待时间。
此外,还有一些改进版的调度算法,如最短剩余时间优先调度算法(Shortest Remaining Time First, SRTF)和多级反馈队列调度算法(Multi-Level Feedback Queue, MLFQ)等,它们在一定程度上兼顾了FCFS和SJF的优势,更适用于实际的操作系统。
操作系统-先来先服务FCFS和短作业优先SJF进程调度算法剖析
操作系统作业算法调度报告学院:专业班级:学生姓名:学号:报告题目:先来先服务和短作业优先算法完成日期:2016年10月25日星期二先来先服务FCFS和短作业优先SJF进程调度算法1、实验目的通过这次实验,加深对进程概念的理解,进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。
2、实验内容问题描述:设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。
假设有n个进程分别在T1, … ,T n时刻到达系统,它们需要的服务时间分别为S1, … ,S n。
分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度,计算每个进程的完成时间、周转时间和带权周转时间,并且统计n个进程的平均周转时间和平均带权周转时间。
3、程序要求:1)进程个数n;每个进程的到达时间T1, … ,T n和服务时间S1, … ,S n;选择算法1-FCFS,2-SJF。
2)要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行,计算每个进程的周转时间和带权周转时间,并且计算所有进程的平均周转时间和带权平均周转时间;3)输出:要求模拟整个调度过程,输出每个时刻的进程运行状态,如“时刻3:进程B开始运行”等等;4)输出:要求输出计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。
4、需求分析(1) 输入的形式和输入值的范围算法选择:FCFS-“1”,选SJF-“2”真实进程数各进程的到达时间各进程的服务时间(2) 输出的形式模拟整个调度过程、周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。
(3) 程序所能达到的功能输入进程个数Num,每个进程到达时间ArrivalTime[i],服务时间ServiceTime[i]。
采用先来先服务FCFS或者短作业优先SJF进程调度算法进行调度,计算每个进程的完成时间、周转时间和带权周转时间,并且统计Num个进程的平均周转时间和平均带权周转时间。
作业调度实验报告
作业调度实验报告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)。
实验二作业调度实验一. 目的要求:用高级语言编写和调试一个或多个作业调度的模拟程序,以加深对作业调度算法的理解。
二. 例题:为单道批处理系统设计一个作业调度程序。
由于在单道批处理系统中,作业一投入运行,它就占有计算机的一切资源直到作业完成为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所占用的 CPU时限等因素。
作业调度算法:采用先来先服务(FCFS)调度算法,即按作业提交的先后次序进行调度。
总是首先调度在系统中等待时间最长的作业。
每个作业由一个作业控制块JCB表示,JCB可以包含如下信息:作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。
作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。
每个作业的最初状态总是等待W。
各个等待的作业按照提交时刻的先后次序排队,总是首先调度等待队列中队首的作业。
每个作业完成后要打印该作业的开始运行时刻、完成时刻、周转时间和带权周转时间,这一组作业完成后要计算并打印这组作业的平均周转时间、带权平均周转时间。
调度算法的流程图如下图所示。
三 . 实习题:1、编写并调试一个单道处理系统的作业等待模拟程序。
作业等待算法:分别采用先来先服务(FCFS),最短作业优先(SJF)、响应比高者优先(HRN)的调度算法。
对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间,以及这组作业的平均周转时间及带权平均周转时间,以比较各种算法的优缺点。
实验代码:#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\t\t软件143赵媛媛\n\n");printf("\t\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);getch();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);getch();}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);getch();}}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(); //调用running()函数}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(); //调用running()函数}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(); //调用running()函数}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();}}main() //主函数{inize();mune();}实验截图2、编写并调度一个多道程序系统的作业调度模拟程序。