实验一 批处理系统的作业调度
操作系统作业调度实验报告
![操作系统作业调度实验报告](https://img.taocdn.com/s3/m/e2aeabfaf5335a8103d22018.png)
#define NULL 0
int n;
float T1=0,T2=0;
int times=0;
struct jcb//作业控制块
{
char name[10]; //作业名
int reachtime; //作业到达时间
3、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间,以及这组作业的平均周转时间及带权平均周转时间。
3)流程图:
二.最短作业优先算法
三.高响应比算法
图一.先来先服务流程图
4)源程序:
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
{
if(m==3) //显示高响应比算法调度作业后的运行情况
{
printf("\n作业%s正在运行,估计其运行情况:\n",q->name);
printf("开始运行时刻:%d\n",q->starttime);
printf("完成时刻:%d\n",q->finishtime);
printf("周转时间:%f\n",q->cycletime);
struct jcb *next; //结构体指针
}*ready=NULL,*p,*q;
typedef struct jcb JCB;
void inize()//初始化界面
{
printf("\n\n\t\t*********************************************\t\t\n");
操作系统实验之处理机调度实验报告
![操作系统实验之处理机调度实验报告](https://img.taocdn.com/s3/m/67a9f555854769eae009581b6bd97f192279bf85.png)
操作系统实验之处理机调度实验报告一、实验目的处理机调度是操作系统中的核心功能之一,本次实验的主要目的是通过模拟不同的处理机调度算法,深入理解操作系统对处理机资源的分配和管理策略,比较不同调度算法的性能差异,并观察它们在不同负载情况下的表现。
二、实验环境本次实验使用的操作系统为 Windows 10,编程语言为 Python 38。
实验中使用了 Python 的相关库,如`numpy`、`matplotlib`等,用于数据生成、计算和图形绘制。
三、实验原理1、先来先服务(FCFS)调度算法先来先服务算法按照作业到达的先后顺序进行调度。
先到达的作业先被服务,直到完成或阻塞,然后再处理下一个到达的作业。
2、短作业优先(SJF)调度算法短作业优先算法选择预计运行时间最短的作业先执行。
这种算法可以有效地减少作业的平均等待时间,但可能导致长作业长时间等待。
3、时间片轮转(RR)调度算法时间片轮转算法将处理机的时间分成固定长度的时间片,每个作业轮流获得一个时间片的处理时间。
当时间片用完后,如果作业还未完成,则将其放入就绪队列的末尾等待下一轮调度。
4、优先级调度算法优先级调度算法为每个作业分配一个优先级,优先级高的作业先被执行。
优先级可以根据作业的性质、紧急程度等因素来确定。
四、实验内容与步骤1、数据生成首先,生成一组模拟的作业,包括作业的到达时间、预计运行时间和优先级等信息。
为了使实验结果更具代表性,生成了不同规模和特征的作业集合。
2、算法实现分别实现了先来先服务、短作业优先、时间片轮转和优先级调度这四种算法。
在实现过程中,严格按照算法的定义和规则进行处理机的分配和调度。
3、性能评估指标定义了以下性能评估指标来比较不同调度算法的效果:平均等待时间:作业在就绪队列中的等待时间的平均值。
平均周转时间:作业从到达系统到完成的时间间隔的平均值。
系统吞吐量:单位时间内完成的作业数量。
4、实验结果分析对每种调度算法进行多次实验,使用不同的作业集合,并记录相应的性能指标数据。
实验一:批处理系统的作业调度
![实验一:批处理系统的作业调度](https://img.taocdn.com/s3/m/5ae70e6e25c52cc58bd6bea7.png)
int printer; //作业执行所需打印机的数量
int tape; //作业执行所需磁带机的数量
int jobcount=0; //系统内现有作业数量
void shedule()
//作业调度函数
{ float xk,k;
int p,q,s,t;
do
{ p=head;
q=s=-1;
k=0;
while(p!=-1)
{ if(jobtable[p].length<=memory&&jobtable[p].tape<=tape&&jobtable[p].printer<=printer)
{ //系统可用资源是否满足作业要求
xk=(float)(jobtable[p].waittime)/jobtable[p].runtime;
jobtable[p].length=size;
jobtable[p].printer=pcount;
jobtable[p].tape=tcount;
jobtable[p].runtime=rtime;
jobtable[p].waittime=wtime;
#include"stdio.h"
#include"string.h"
#define n 10 //假定系统中可容纳的作业数量为n
typedef struct jcb
{ char name[4]; //作业名
head=jobtable[head].next;
else
jobtable[t].next=jobtable[q].next;
批处理系统中的作业调度
![批处理系统中的作业调度](https://img.taocdn.com/s3/m/0ae0b067fc4ffe473268ab06.png)
批处理系统中作业调度(2008-06-02 10:40:34) 转载标签:学习操作系统代码文化批处理系统中作业调度:#include"stdlib.h"#include"string.h"#include"iostream.h" typedef struct cj {char name[6];int length;int printer;int tape;int runtime;int waittime;struct cj *next;}cj;cj *head;int tape,printer;long memory;void shedule(){float xk,k;cj *p,*q,*s,*t;do{p=head;q=s=NULL;k=0;while(p!=NULL){if(p->length<=memory&&p->tape<=tape&&p->printer<=printer) {xk=(float)(p->waittime)/p->runtime;if(q==NULL||xk>k){k=xk;q=p;t=s;}}s=p;p=p->next;}if(q!=NULL){if(t==NULL)head=head->next;elset->next=q->next;memory=memory-q->length;tape=tape-q->tape;printer=printer-q->printer;cout<<"选中作业的作业名:"<<q->name<<"\n";}}while(q!=NULL);}void main(){int size,tcount,pcount,wtime,rtime;char name[6];cj *p;memory=65536;printer=2;tape=4;head=NULL;cout<<"输入作业相关数据(以作业大小为负数停止输入):\n";cout<<"输入作业名、作业大小、磁带机数、打印机数、等待时间、估计执行时间\n"; cin>>name>>size>>tcount>>pcount>>wtime>>rtime;while(size!=-1){p=(cj*)malloc(sizeof(cj));strcpy(p->name,name);p->length=size;p->printer=pcount;p->tape=tcount;p->runtime=rtime;p->waittime=wtime;p->next=head;head=p;cout<<"输入作业名、作业大小、磁带机数、打印机数、等待时间、估计执行时间\n"; cin>>name>>size>>tcount>>pcount>>wtime>>rtime;}shedule();}操作系统批处理系统的作业调度模拟2007-01-16 07:15 P.M.花了一天半的时间才编好~~希望对有这个需要的朋友能用的上!声明一下~我是用win tc编写的,如果用tc的话可能有时会无法运行,原因我还没弄清楚。
批处理系统的作业调度
![批处理系统的作业调度](https://img.taocdn.com/s3/m/666a8f4d336c1eb91a375d2d.png)
实验批处理系统的作业调度一、实验目的(1)加深对作业概念的理解;(2)深入了解批处理系统如何组织作业、管理作业和调度作业。
二、预备知识(1)批处理系统的概念;批处理系统,又名批处理操作系统。
批处理是指用户将一批作业提交给操作系统后就不再干预,由操作系统控制它们自动运行。
这种采用批量处理作业技术的操作系统称为批处理操作系统。
批处理操作系统分为单道批处理系统和多道批处理系统。
批处理操作系统不具有交互性,它是为了提高CPU的利用率而提出的一种操作系统。
1.作用:大家知不知道默认共享这回事?这东西用不着的地方可就不是好东西了.所以就要删掉.但这东西是每次系统重起后都会重新创建的.所以每次都要重新打开cmd重新删掉一下.极为麻烦.但有了批处理文件就不一样了,先把命令输入到批处理文件中,然后加入到启动项中,每次启动就会自动运行,免去了每次输入命令的麻烦.(2).如何创建批处理文件?不要听了批处理文件就感到很神气,其实这东西很简单的.你用过记事本没有?用过?好的.将记事本打开,什么都不用写,然后选择文件,保存.保存类型选择所有文件,文件名则命名为*.bat 这个*代表是文件名,你可以随便的起.保存好之后,看看你保存的地方,会出现一个白色窗口里有个黄色齿轮的图标.这东西就是你创建的批处理文件,双击他就可以运行,但他现在由于里面没有输入任何命令,所以他运行了并不会做任何事情.当我们想往这个*.bat文件中添加东西时,只要右键选择他,然后选择编辑,就可以打开记事本往内输入命令了.3.批处理文件中的命令是什么?批处理文件中的命令暂时先可以理解为dos命令,等稍后深入理解了以后再进行解释.批处理顾名思义就是一大堆东西堆在一起处理.换句话说就是往里面写一条条dos命令,然后按顺序挨个执行,效果跟你在cmd里敲dos命令是一个效果.只不过用批处理写好之后,要运行只要双击下就可以运行了.而不用再一遍一遍的重复的往里面打命令.这就是批处理文件的好处.(2)批处理系统的调度。
处理机调度实验报告
![处理机调度实验报告](https://img.taocdn.com/s3/m/45e65375f011f18583d049649b6648d7c1c708f0.png)
处理机调度实验报告处理机调度实验报告一、引言处理机调度是计算机操作系统中一个重要的概念,它涉及到如何合理地分配处理机资源以提高系统的运行效率。
本文将针对处理机调度进行实验,探讨不同调度算法对系统性能的影响。
二、实验目的本实验的目的是通过模拟不同的处理机调度算法,比较它们在不同负载下的性能表现,进而分析其优缺点,为实际操作系统的调度算法选择提供参考。
三、实验方法1. 实验环境本实验使用了一台配置较高的计算机作为实验环境,操作系统为Linux,处理器为Intel Core i7,内存为8GB。
2. 实验设置为了模拟不同的负载情况,我们使用了三个不同的测试程序:程序A、程序B和程序C。
程序A是一个计算密集型任务,程序B是一个I/O密集型任务,程序C是一个混合型任务。
3. 实验步骤首先,我们分别运行程序A、程序B和程序C,并记录它们的运行时间。
然后,我们使用不同的调度算法来调度这些任务,并记录它们的运行时间和系统资源利用率。
四、实验结果与分析1. 调度算法1:先来先服务(First-Come, First-Served,FCFS)FCFS算法按照任务到达的先后顺序进行调度,即先到先服务。
实验结果显示,在计算密集型任务下,FCFS算法表现较好,但在I/O密集型任务和混合型任务下,其性能明显下降。
这是因为在FCFS算法中,任务的执行顺序是固定的,无法根据任务的特性进行灵活调度。
2. 调度算法2:最短作业优先(Shortest Job First,SJF)SJF算法根据任务的执行时间进行调度,即执行时间最短的任务先执行。
实验结果显示,在计算密集型任务和混合型任务下,SJF算法表现较好,但在I/O密集型任务下,其性能较差。
这是因为在I/O密集型任务中,任务的执行时间不仅与计算量有关,还与I/O操作的耗时有关,因此SJF算法无法有效地进行调度。
3. 调度算法3:时间片轮转(Round Robin,RR)RR算法将处理机的运行时间划分为若干个时间片,每个任务在一个时间片内执行一定的时间,然后切换到下一个任务。
操作系统实验报告作业调度
![操作系统实验报告作业调度](https://img.taocdn.com/s3/m/0ba3b76db5daa58da0116c175f0e7cd184251892.png)
操作系统实验报告作业调度操作系统实验报告:作业调度引言作业调度是操作系统中的重要部分,它负责管理和调度系统中的各种作业,以最大化系统资源的利用率和提高作业的执行效率。
在本次实验中,我们将探讨作业调度的基本原理和实现方法,并通过实验验证其效果。
实验目的本次实验的主要目的是通过实际操作,了解作业调度的基本原理和实现方法,掌握作业调度的相关算法,并通过实验验证其有效性。
实验内容1. 实现作业调度的基本算法在本次实验中,我们将实现作业调度的基本算法,包括先来先服务(FCFS)、最短作业优先(SJF)、优先级调度(Priority Scheduling)和多级反馈队列调度(Multilevel Feedback Queue Scheduling)等。
通过编写代码,模拟这些算法的执行过程,并观察它们的效果。
2. 实验验证我们将设计一些测试用例,通过模拟作业的执行过程,分别使用不同的作业调度算法,并比较它们的执行效果。
通过实验验证,我们将得出不同算法的优劣势,并分析其适用场景。
实验结果经过实验验证,我们得出以下结论:1. 先来先服务(FCFS)算法适用于作业执行时间相对均匀的情况,但可能会导致平均等待时间较长。
2. 最短作业优先(SJF)算法能够最大程度地减少平均等待时间,但可能会出现作业饥饿现象。
3. 优先级调度(Priority Scheduling)算法能够根据作业的优先级进行调度,适用于有明确优先级需求的情况。
4. 多级反馈队列调度(Multilevel Feedback Queue Scheduling)算法能够根据作业的执行情况动态调整优先级,适用于各种类型的作业。
结论作业调度是操作系统中的重要组成部分,不同的作业调度算法适用于不同的场景。
通过本次实验,我们深入了解了作业调度的基本原理和实现方法,掌握了不同算法的优劣势,并通过实验验证了它们的有效性。
这将对我们进一步深入学习操作系统和提高系统性能有着重要的意义。
操作系统原理实验教学大纲(本科)-2013
![操作系统原理实验教学大纲(本科)-2013](https://img.taocdn.com/s3/m/ae8e32079a6648d7c1c708a1284ac850ad020490.png)
《操作系统原理》实验教学大纲一、实验教学内容与基本要求实验一 批处理系统的作业调度1 目的要求1.加深对作业概念的理解;2.深入了解批处理系统如何组织作业、管理作业和调度作业。
2 实验内容编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。
实验具体包括:首先确定作业控制块的内容,作业控制块的组成方式;然后完成作业调度;最后编写主函数对所做工作进行测试。
3 所需实验设施设备PC、windows操作系统4 教学形式及过程演示、学生独立完成实验二 进程管理1 目的要求1.加深对进程概念的理解,明确进程和程序的区别。
2.深入了解系统如何组织进程、创建进程。
3.进一步认识如何实现处理器调度。
2 实验内容编写程序完成单处理机系统中的进程调度,要求采用时间片轮转调度算法。
实验具体包括:首先确定进程控制块的内容,进程控制块的组成方式;然后完成进程创建原语和进程调度原语;最后编写主函数对所做工作进行测试。
3 所需实验设施设备PC、windows操作系统4 教学形式及过程演示、学生独立完成实验三 动态分区存储管理方式的主存分配回收1 目的要求深入了解动态分区存储管理方式主存分配回收的实现。
2 实验内容编写程序完成动态分区存储管理方式的主存分配回收的实现。
实验具体包括:首先确定主存空间分配表;然后采用最优适应算法完成主存空间的分配和回收;最后编写主函数对所做工作进行测试。
3 所需实验设施设备PC、windows操作系统4 教学形式及过程演示、学生独立完成实验四 页式虚拟存储管理中地址转换和缺页中断1 目的要求1.深入了解页式存储管理如何实现地址转换;2.进一步认识页式虚拟存储管理中如何处理缺页中断。
2 实验内容编写程序完成页式存储管理中地址转换过程和模拟缺页中断的处理。
实验具体包括:首先对给定的地址进行地址转换工作,若发生缺页则先进行缺页中断处理,然后再进行地址转换;最后编写主函数对所做工作进行测试。
实验一 处理机调度实验报告
![实验一 处理机调度实验报告](https://img.taocdn.com/s3/m/5f3db080ac51f01dc281e53a580216fc700a53e5.png)
实验一处理机调度实验报告一、实验目的处理机调度是操作系统中的一个重要组成部分,其目的是合理地分配处理机资源,以提高系统的性能和效率。
本次实验的主要目的是通过模拟处理机调度算法,深入理解不同调度算法的工作原理和性能特点,并能够对它们进行比较和分析。
二、实验环境本次实验使用了以下软件和工具:1、操作系统:Windows 102、编程语言:Python3、开发环境:PyCharm三、实验内容1、先来先服务(FCFS)调度算法先来先服务调度算法按照作业或进程到达的先后顺序进行调度。
即先到达的作业或进程先得到处理机的服务。
2、短作业优先(SJF)调度算法短作业优先调度算法优先调度运行时间短的作业或进程。
在实现过程中,需要对作业或进程的运行时间进行预测或已知。
3、高响应比优先(HRRN)调度算法高响应比优先调度算法综合考虑作业或进程的等待时间和运行时间。
响应比的计算公式为:响应比=(等待时间+要求服务时间)/要求服务时间。
4、时间片轮转(RR)调度算法时间片轮转调度算法将处理机的时间分成固定大小的时间片,每个作业或进程在一个时间片内运行,当时间片用完后,切换到下一个作业或进程。
四、实验步骤1、设计数据结构为了表示作业或进程,设计了一个包含作业或进程 ID、到达时间、运行时间和等待时间等属性的数据结构。
2、实现调度算法分别实现了上述四种调度算法。
在实现过程中,根据算法的特点进行相应的处理和计算。
3、模拟调度过程创建一组作业或进程,并按照不同的调度算法进行调度。
在调度过程中,更新作业或进程的状态和相关时间参数。
4、计算性能指标计算了平均周转时间和平均带权周转时间等性能指标,用于评估不同调度算法的性能。
五、实验结果与分析1、先来先服务(FCFS)调度算法平均周转时间:通过计算所有作业或进程的周转时间之和除以作业或进程的数量,得到平均周转时间。
在 FCFS 算法中,由于按照到达顺序进行调度,可能会导致长作业或进程长时间占用处理机,从而使平均周转时间较长。
单道批处理系统作业调度
![单道批处理系统作业调度](https://img.taocdn.com/s3/m/054e4937f68a6529647d27284b73f242336c31a0.png)
单道批处理系统作业调度单道批处理系统作业调度是指在单道批处理系统中,根据作业的特性和系统资源的情况,合理地安排作业的执行顺序和分配系统资源的过程。
它是操作系统中的一个重要组成部分,对于提高系统的效率和资源利用率至关重要。
一、作业调度的原则1. 公平性原则:保证每个作业都有机会获得系统资源,避免某些作业长时间占用资源而导致其他作业等待过久。
2. 高效性原则:尽量减少作业的等待时间,提高系统的吞吐量和响应速度。
3. 紧急性原则:优先处理紧急的作业,确保系统的稳定运行。
4. 先来先服务原则:按照作业提交的先后顺序进行调度,保证公平性和公正性。
二、作业调度的算法1. 先来先服务(FCFS)算法:按照作业提交的先后顺序进行调度,先提交的作业先执行。
适用于作业的执行时间相对较短且相对稳定的情况。
2. 短作业优先(SJF)算法:根据作业的执行时间预测,选择执行时间最短的作业优先执行。
适用于作业的执行时间差异较大的情况。
3. 优先级调度算法:为每个作业分配一个优先级,根据优先级高低进行调度。
适用于需要根据作业的重要性和紧急程度进行调度的情况。
4. 时间片轮转(RR)算法:将系统的执行时间划分为多个时间片,每个作业在一个时间片内执行一定的时间,然后切换到下一个作业。
适用于多个作业之间的执行时间相对均衡的情况。
三、作业调度的流程1. 作业提交:用户将作业提交到系统中,包括作业的名称、优先级、执行时间等信息。
2. 作业入队:将提交的作业加入到作业队列中,按照先来先服务或者其他调度算法进行排序。
3. 作业调度:根据调度算法选择下一个执行的作业,并将其从作业队列中取出。
4. 资源分配:根据作业的资源需求,分配相应的系统资源给作业,如CPU、内存等。
5. 作业执行:作业开始执行,占用系统资源进行计算、IO操作等。
6. 作业完成:作业执行完毕后,释放占用的系统资源,并将结果返回给用户。
7. 下一个作业:根据调度算法选择下一个执行的作业,重复步骤3-6,直到所有作业执行完毕。
2023年操作系统作业调度实验报告
![2023年操作系统作业调度实验报告](https://img.taocdn.com/s3/m/77eb119c64ce0508763231126edb6f1aff0071ec.png)
实验二作业调度实验题目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作业证在运行,估计其运行情况: 开始运宜时刻:。
操作系统 批处理系统作业调度实验报告
![操作系统 批处理系统作业调度实验报告](https://img.taocdn.com/s3/m/68ad0357f78a6529647d53b7.png)
操作系统批处理系统作业调度实验报告批处理系统的作业调度实验报告年级 2009级学号 2009443004 姓名郭占强成绩专业生物信息学实验地点生科楼409 指导教师王硕实验项目批处理系统的作业调度实验日期 2011年11月18日一、实验目的加深对作业概念的理解;深入了解批处理系统如何组织作业、管理作业和调度作业。
二、实验要求编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。
实验具体包括:首先确定作业控制块的内容,作业控制块的组成方式;然后完成作业调度;最后编写主函数对所作工作进程测试。
三、实验原理:操作系统根据允许并行工作的道数和一定的算法从系统中选取若干作业把它们装入主存储器,使它们有机会获得处理器运行。
四、实验程序设计#include "string.h"#include<iostream.h>#include<stdio.h>#define n 10 /*假定系统中可容纳的作业数量为n*/typedef struct jcb{char name[4]; /*作业名*/int length; /*作业长度,所需主存大小*/int printer; /*作业执行所需打印机的数量*/int tape; /*作业执行所需磁带机的数量*/int runtime; /*作业估计执行时间*/int waittime; /*作业在系统中的等待时间*/int next; /*指向下一个作业控制块的指针*/}JCB; /*作业控制块类型定义*/int head; /*作业队列头指针定义*/int tape,printer;long memory;JCB jobtable[n]; /*作业表*/int jobcount=0; /*系统内现有作业数量*/shedule( )- 1 -/*作业调度函数*/{float xk,k;int p,q,s,t;do{p=head;q=s=-1;k=0;while(p!=-1){ if(jobtable[p].length<=memory&&jobtable[p].tape<=tape&&jobtable[p] .printer<=printer){ /*系统可用资源是否满足作业需求*/xk=(float)(jobtable[p].waittime)/jobtable[p].runtime;if(q==0||xk>k) /*满足条件的第一个作业或者作业q的响应比小于作业p的响应比*/{k=xk; /*记录响应比*/q=p;t=s;}/*if*/}/*if*/s=p;p=jobtable[p].next; /*指针p后移*/}/*while*/if(q!=-1){ if(t==-1) /*是作业队列的第一个*/head=jobtable[head].next;elsejobtable[t].next=jobtable[q].next;/*为作业q分配资源:分配主存空间;分配磁带机;分配打印机*/memory=memory-jobtable[q].length;tape=tape-jobtable[q].tape;printer=printer-jobtable[q].printer;printf("选中作业的作业名:%s\n",jobtable[q].name);}}while(q!=-1);}/*作业调度函数结束*/main( ){char name[4];int size,tcount,pcount,wtime,rtime;int p;/*系统数据初始化*/memory=65536;tape=4;printer=2;head=-1;printf("输入作业相关数据(以作业大小为负数停止输入):\n");/*输入数据,建立作业队列*/- 2 -printf("输入作业名、作业大小、磁带机数、打印机数、等待时间、估计执行时间\n");scanf("%s%d%d %d %d %d",name,&size,&tcount,&pcount,&wtime,&rtime);while(size!=-1){/*创建JCB*/if(jobcount<n)p=jobcount;else { printf("无法再创建作业\n");break;}jobcount++;/*填写该作业相关内容*/strcpy(jobtable[p].name,name);jobtable[p].length=size;jobtable[p].printer=pcount;jobtable[p].tape=tcount;jobtable[p].runtime=rtime;jobtable[p].waittime=wtime;/*挂入作业队列队首*/jobtable[p].next=head;head=p;/* 输入一个作业数据*/printf("输入作业名、作业大小、磁带机数、打印机数、等待时间、估计执行时间\n");scanf("%s%d%d%d%d%d",name,&size,&tcount,&pcount,&wtime,&rtime);}/*while*/shedule( ); /*进行作业调度*/}/*main( )函数结束*/五、实验结果与分析1. 本程序采用响应比高者优先算法进行作业调度。
实验一 编程模拟处理机调度
![实验一 编程模拟处理机调度](https://img.taocdn.com/s3/m/01842c1fc5da50e2524d7fd6.png)
一、实验教学内容与基本要求(时间:10月8号)实验一批处理系统的作业调度1 目的要求1.加深对作业概念的理解;2.深入了解批处理系统如何组织作业、管理作业和调度作业。
2 实验内容编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。
实验具体包括:首先确定作业控制块的内容,作业控制块的组成方式;然后完成作业调度;最后编写主函数对所做工作进行测试。
3 所需实验设施设备PC、windows操作系统4 教学形式及过程演示、学生独立完成重要数据结构:1. 作业信息Struct jobinfo {Int jid; 作业IDInt pid;进程IDChar** cmdarg;命令参数Int defpri;默认优先级Int curpri;当前优先级Int ownerid;作业所有者IDInt waittime;作业在队列中等待时间Time-t creat-time;作业创建时间Int runtime;作业运行时间Enum jobjobstate state;作业状态};2. 作业调度命令Struct jobcmd{Enum cmdtype;Int argnum;Int owner;Int defpri;Char data[buflen];};3. 就绪队列Struct waitqueue{Struct waitqurue *next;Struct jobinfo *job;};4. 作业状态Enum jobstate{Ready,running,done};实验一编程模拟处理机调度(实现一种算法)一、实验内容选择一个调度算法,实现处理器调度。
二、实验目的在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。
当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。
本实习模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。
三、实验题目设计一个按优先数调度算法实现处理器调度的程序。
(完整word版)操作系统作业调度实验报告-多道批处理
![(完整word版)操作系统作业调度实验报告-多道批处理](https://img.taocdn.com/s3/m/32722f6851e79b89680226f0.png)
计算机学院计算机科学与技术专业07 班姓名学号教师评定_________________实验题目作业调度一、实验目的本实验要求学生模拟作业调度的实现,用高级语言编写和调试一个或多个作业调度的模拟程序,了解作业调度在操作系统中的作用,以加深对作业调度算法的理解。
二、实验内容和要求1、为单道批处理系统设计一个作业调度程序(1)、编写并调试一个单道处理系统的作业调度模拟程序。
(2)、作业调度算法:分别采用先来先服务(FCFS),最短作业优先(SJF)的调度算法。
(3)、由于在单道批处理系统中,作业一投入运行,它就占有计算机的一切资源直到作业完成为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所占用的CPU时限等因素。
(4)、每个作业由一个作业控制块JCB表示,JCB可以包含如下信息:作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。
作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。
每个作业的最初状态总是等待W。
(5)、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间,以及这组作业的平均周转时间及带权平均周转时间,并比较各种算法的优缺点。
2、模拟批处理多道操作系统的作业调度(1)写并调试一个作业调度模拟程序。
(2)作业调度算法:分别采用先来服务(FCFS)调度算法。
(3)在批处理系统中,要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求,所需要的资源是否得到满足。
作业调度程序负责从输入井选择若干个作业进入主存,为它们分配必要的资源,当它们能够被进程调度选中时,就可占用处理机运行。
作业调度选择一个作业的必要条件是系统中现有的尚未分配的资源可满足该作业的资源要求。
但有时系统中现有的尚未分配的资源既可满足某个作业的要求也可满足其它一些作业要求,那么,作业调度必须按一定的算法在这些作业中作出选择。
批处理系统的作业调度java
![批处理系统的作业调度java](https://img.taocdn.com/s3/m/b07cafe581c758f5f61f67bd.png)
实验批处理系统的作业调度一、实验目的(1)加深对作业概念的理解;(2)深入了解批处理系统如何组织作业、管理作业和调度作业。
二、预备知识(1).三、实验内容编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。
实验具体包括:首先确定作业块的内容和组成方式;然后完成作业调度;最后编写主函数,对所做工作进行测试。
import java.util.Scanner;public class JCB {public String name; //作业名public int length; //作业长度public int print; //打印机数量public int tape; //磁带机数量public int runTime;public int waitTime;public int next; //指针}class Action{public final int n=10; //后备队列中JCB的最大数量JCB[] jTable=new JCB[n]; //作业表public int jCount; //作业表中当前作业数量public int head; //作业表头指针//初始化函数public void Init(){head=-1;jCount=0;}//入队函数public void pushQueue(JCB jcb){if(jCount>=n){System.out.println("队列已满!不能再加入!");return ;}if(head==-1)head=0;// System.out.println(jTable[jCount]);jTable[jCount]=new JCB();jTable[jCount].length=jcb.length;jTable[jCount].name=;jTable[jCount].print=jcb.print;jTable[jCount].tape=jcb.tape;jTable[jCount].runTime=jcb.runTime;jTable[jCount].waitTime=jcb.waitTime;jTable[jCount].next=-1;jCount++;}//出队函数public void popQueue(int num){if(jCount==0){System.out.println("空的队列!不能出队!");return ;}if(num>=jCount){System.out.println("队列中不存在该元素!");return ;}if(jCount==1){head=-1;jTable[0].next=-1;jCount=0;}else{jTable[num-1].next=jTable[num].next;jTable[num].next=-1;jCount--;}}public int memory=64*1024; //主存大小64MBpublic int tape=4; //磁带机数量public int print=2; //打印机数量//作业调度函数public void dispatch(){int currJcb,maxJcb;double currJcbRate,maxJcbRate;while(head!=-1){currJcb=maxJcb=head;currJcbRate=maxJcbRate=0;//找出响应比最大的作业while(true){//找出满足资源的作业if(jTable[currJcb].length<=memory&&jTable[currJcb].tape<=tape&&jTable [currJcb].print<=print){//计算响应比currJcbRate=(double)jTable[currJcb].waitTime/jTable[currJcb].runTime;if(currJcbRate>maxJcbRate){maxJcbRate=currJcbRate;maxJcb=currJcb;}}if(jTable[currJcb].next==-1){break;}else{currJcb=jTable[currJcb].next;}}//输出响应比最大的作业、分配资源if(maxJcbRate!=0){memory-=jTable[maxJcb].length;tape-=jTable[maxJcb].tape;tape-=jTable[maxJcb].print;System.out.println("选中的作业的作业名为:"+jTable[maxJcb].name);popQueue(maxJcb);}}}public static void main(String[] args) {String name;int length;int print;int tape;int runTime;int waitTime;int count; //记录输入作业数量JCB jcb =new JCB(); //临时作业变量System.out.println("请输入作业相关信息,以作业名为Q为输入结束。
操作系统之实验-作业调度
![操作系统之实验-作业调度](https://img.taocdn.com/s3/m/332e2cfa04a1b0717fd5ddc2.png)
作业调度一、实习内容模拟批处理多道操作系统的作业调度。
二、实习目的每个用户请求计算机的一个计算任务叫做一个作业。
一个作业从初始数据到得到计算结果,要经过若干个步骤的相继执行。
例如,编辑、编译、运行等,其中每一个步骤称作一个作业步。
用户向系统提出作业加工的方式称作业控制方式,作业控制方式有两种:终端控制方式(又称直接控制方式或联机控制方式)和批处理控制方式(又称自动控制方式或脱机控制方式)。
在批处理控制方式下,用户采用系统提供的作业控制语言(JCL)写好作业说明书,说明作业加工的步骤。
操作员把一批作业组织成输入流,通过“预输入”手段使每个作业的信息(包括作业说明书、源程序、初始数据等)暂存在辅助存储器的“输入井”中。
批处理多道操作系统的作业管理有两个任务:作业调度和作业控制。
采用多道程序设计方法的操作系统,在系统中要经常保留多个运行的作业,以提高系统效率。
作业调度从系统已接纳的暂存在输入井中的一批作业中挑选出若干个可运行的作业,并为这些被选中的作业分配所需的系统资源。
对被选中运行的作业,必须按照它们各自的作业说明书规定的步骤进行控制。
本实习要求学生模拟作业调度的实现,了解作业调度在操作系统中的作用。
三、实习题目采用先来先服务算法和运行时间最短者优先算法模拟设计作业调度程序。
【提示】(1)作业调度程序负责从输入井选择若干个作业进入主存,为它们分配必要的资源,当它们能够被进程调度选中时,就可以占用处理器运行,作业调度选择一个作业的必要条件是系统中现有的尚未分配的资源可以满足该作业的资源需求。
但有进系统中现有的尚未分配的资源既可满足某个作业的要求也可以满足其它一些作业的要求,那么,作业调度必须按照一定的算法在这些作业中作出选择。
先来先服务算法是按照作业进入输入井的先后次序来挑选作业,先进入输入井的作业优先被挑选,当系统中现有的尚未分配的资源不能满足先进入输入井的作业时,那么顺序挑选后面的作业。
运行时间最短者优先算法总是按作业要求能满足的作业先进入主存执行。
[计算机]作业调度实验报告
![[计算机]作业调度实验报告](https://img.taocdn.com/s3/m/99f1345cc950ad02de80d4d8d15abe23482f0337.png)
实验项目名称作业调度实验目的及要求一、实验目的:1、通过模拟作业调度算法的设计加深对作业管理基本原理的理解。
2、深入了解批处理系统如何组织作业、管理作业和调度作业。
3、掌握作业调度算法。
二、实验要求:1、编写程序完成实验内容;2、对测试数据进行分析;3、撰写实验报告。
实验内容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设备的类型和数量等)、进入系统时间、开始处理时间、作业完成时间、作业退出时间、资源使用情况等。
三、作业调度作业调度的主要功能是根据作业控制块中的信息,审查系统能否满足用户作业的资源需求,以及按照一定的算法,从外存的后备队列中选取某些作业调入内存,并为它们创建进程、分配必要的资源。
然后再将新创建的进程插入就绪队列,准备执行。
操作系统实验报告作业调度
![操作系统实验报告作业调度](https://img.taocdn.com/s3/m/76d85ccdd1d233d4b14e852458fb770bf78a3bc0.png)
操作系统实验报告:作业调度1. 引言作业调度是操作系统中的一个重要概念,它涉及到如何合理地安排计算机系统中的作业执行顺序,以最大程度地提高系统的效率和性能。
本文将介绍作业调度的基本概念和主要算法,以及在实验中的应用。
2. 作业调度的概念作业调度是指根据一定的策略和算法,按照一定的顺序从作业队列中选取作业,将其分配给可用资源来执行的过程。
作业调度的目标是实现公平、高效的任务分配,以提高系统的整体性能。
3. 作业调度算法3.1 先来先服务(FCFS)先来先服务是最简单的作业调度算法,即按照作业提交的顺序来执行。
当一份作业到达系统后,它将被放入作业队列的末尾。
一旦当前执行的作业完成,系统将选择队列中的下一个作业来执行。
3.2 短作业优先(SJF)短作业优先算法是根据作业的执行时间来进行调度,执行时间越短的作业优先级越高。
当一个作业进入系统时,系统会检查队列中的所有作业,并选择执行时间最短的作业来执行。
3.3 优先级调度优先级调度算法是根据作业的优先级来进行调度,优先级越高的作业优先级越高。
每个作业都会被分配一个优先级值,系统会按照优先级从高到低的顺序来执行作业。
3.4 时间片轮转调度时间片轮转调度算法将作业分为多个时间片,每个时间片的执行时间相等。
当一个作业进入系统时,系统会分配给它一个时间片,如果在时间片内作业没有完成,则将其放回队列的末尾,并执行下一个作业。
4. 实验中的应用在操作系统实验中,作业调度是一个重要的实验内容。
通过实验,我们可以深入了解不同调度算法的特点和适用场景。
实验中,我们可以使用模拟器来模拟作业调度的过程。
我们可以创建一个作业队列,然后使用不同的调度算法来执行这些作业,并记录它们的执行时间和系统的吞吐量。
通过实验,我们可以比较不同算法在不同场景下的表现,选择最适合当前系统的作业调度算法。
5. 结论作业调度是一个重要的操作系统概念,它决定了系统的性能和效率。
在本文中,我们介绍了作业调度的基本概念和常用算法,并讨论了在实验中的应用。
操作系统实验报告-批处理系统的作业调度
![操作系统实验报告-批处理系统的作业调度](https://img.taocdn.com/s3/m/962c2808876fb84ae45c3b3567ec102de2bddf28.png)
#include
#include
#include
#include
#include
typedefcharstring[10];/*//定义string为含有10个字符元素的字符数组类型*/
structtask{
stringname;/*作业号*/
intarrtime;/*作业抵达时间*/
操作系统实验报告-批处理系统的作业调度
实验一批处理系统的作业调度
(1)加深对作业概念的理解。
(2)深入细致介绍批处理系统如何非政府作业、管理作业和调度作业。
编写程序完成批处理系统的作业调度,要求采用响应比优先调度算法。
最低积极响应比优先法(hrrn)就是对fcfs方式和sjf方式的一种综合均衡。hrrn调度策略同时考量每个作业的等待时间长短和估算须要的继续执行时间长短,从中挑选出积极响应比最低的作业资金投入继续执行。
printf("%9s%9d%9d%9d%9d%9d%9d\n",
jcb[i].name,jcb[i].arrtime,jcb[i].sertime,
jcb[i].begtime,jcb[i].fintime,jcb[i].turtime,jcb[i].wtutime);
voidcheck()
intstatime,endtime,sumturtime=0.0,sumwtutime=0.0,aveturtime,avewtutime;intcurrent=0,times=0,pre=0;
printf("-------------------------------------------------------------------------\n");
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验一批处理系统的作业调度
一、实验目的
1.加深对作业概念的理解。
2.深入了解批处理系统如何组织作业、管理作业和调度作业。
二、实验预备知识
1.作业的概念。
2.作业的创建。
3.作业的调度。
三、实验内容
编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。
实验具体包括:首先确定作业控制块的内容,作业控制块的组成方式;然后完成作业调度;最后编写主函数对所做工作进行测试。
四、提示与讲解
操作系统根据允许并行工作的道数和一定的算法从系统中选取若干作业把它们装入主存储器,使它们有机会获得处理器运行,这项工作被称为“作业调度”。
实现这部分功能的程序就是“作业调度程序”。
作业调度的实现主要有两个问题,一个是如何将系统中的作业组织起来;另一个是如何进行作业调度。
为了将系统中的作业组织起来,需要为每个进入系统的作业建立档案以记录和作业相关的信息,例如作业名、作业所需资源、作业执行时间、作业进入系统的时间、作业信息在存储器中的位置、指向下一个作业控制块的指针等信息。
这个记录作业相关信息的数据块称为作业控制块(JCB),并将系统中等待作业调度的作业控制块组织成一个队列,这个队列称为后备队列。
一个作业全部信息进入系统后,就为其建立作业控制块,并挂入后备队列。
当进行作业调度时,从后备队列中查找选择作业。
由于实验中没有实际作业,作业控制块中的信息内容只使用了实验中需要的数据。
作业控制块中首先应该包括作业名;其次是作业所需资源,根据需要,实验中只包括需要主存的大小(采用可移动的动态分区方式管理主存,作业大小就是需要主存的大小)、需要打印机的数量和需要磁带机的数量;采用响应比作业调度算法,为了计算响应比,还需要有作业的估计执行时间、作业在系统中的等待时间;另外,指向下一个作业控制块的指针必不可少。
实验中,作业控制块及队列的数据结构定义如下:
typedef struct jcb
{ char name[4]; //作业名
int length; //作业长度,所需主存大小
int printer; //作业执行所需打印机的数量
int tape; //作业执行所需磁带机的数量
int runtime; //作业估计执行时间
int waittime; //作业在系统中的等待时间
int next; //指向下一个作业控制块的指针
} JCB //作业控制块类型定义
存放作业控制块的区域:
#define n 10 //假定系统中可容纳的作业数量为n
JCB jobtable[10]; //作业表
int jobcount; //系统内现有作业数量
将作业控制块组织成一个队列,实验中采用静态链表的方式模拟作业的后备队列,如图1所示。
作业队列头指针定义:
int *head;
图1 采用响应比高者优先算法的作业调度程序流程图
确定作业组织方式之后,就要开始考虑如何进行作业调度。
尽管不同的计算机系统可以采用不同的调度原则和调度算法,但是都必须遵循一个必要条件,即系统现有的尚未分配的资源可以满足被选作业的资源要求。
就是说,所有的作业调度都是按照一定的算法,从满足必要条件的作业中选择一部分作业装入主存储器。
实验中,主存采用可移动的动态分区管理方法,即只要主存空闲区总和比作业大就可以满足作业对主存的需求;对打印机和磁带机这两种独占型设备采用静态分配法,即作业执行前必须获得所需资源,并且执行完才归还。
常用的作业调度算法有先来先服务算法、计算时间短的作业优先算法、响应比高者优先算法、优先数调度算法和均衡调度算法。
实验中采用响应比高者优先算法,响应比的定义为:响应比=作业的等待时间/作业估计执行时间
采用响应比高者优先调度算法,进行调度时必须计算出系统中的所有满足必要条件作业的响应比;从中选择响应比最高的一个作业装入主存储器分配资源,由于是实验,所以就用将作业的作业控制块出队,并输出作业的作业名代替装入主存储器,同时修改系统的资源数量;用同样方法选择第二个、第三个……直到不再有满足必要条件的作业。
采用响应比高者优先算法的作业调度程序流程图如图1所示。
模拟程序中,首先要假设系统的资源情况,假设系统资源只有主存(memory)64MB(以KB为单位分配)、磁带机(tape)4台和打印机(printer)2台;然后,手工输入某个时刻系统中的各个作业情况;最后进行作业调度,并将结果输出。
五、课外题
将上述实验中的作业调度算法改为短作业优先调度算法重新完成上述工作。
六、参考程序
#include "string.h"
#define n 10 //假定系统中可容纳的作业数量为n
typedef struct jcb
{ char name[4]; //作业名
int length; //作业长度,所需主存大小
int printer; //作业执行所需打印机的数量
int tape; //作业执行所需磁带机的数量
int runtime; //作业估计执行时间
int waittime; //作业在系统中的等待时间
int next; //指向下一个作业控制块的指针
}JCB; //作业控制块类型定义
int head; //作业队列头指针定义
int tape,printer;
long memory;
JCB jobtable[n]; //作业表
int jobcount=0; //系统内现有作业数量
shedule( )
//作业调度函数
{float xk,k;
int p,q,s,t;
do
{ p=head;
q=s=-1;
k=0;
while(p!=-1)
}
{if(jobtable[p].length<=memory&&jobtable[p].tape<=tape&&jobtable[p].print er<=printer)
{ //系统可用资源是否满足作业需求
xk=(float)(jobtable[p].waittime)/jobtable[p].runtime;
if(q==0||xk>k)
//满足条件的第一个作业或者作业q的响应比小于作业p的响应比
{ k=xk; //记录响应比
q=p;
t=s;
}//if
}//if
s=p;
p=jobtable[p].next; //指针p后移
}//while
if(q!=-1)
{ if(t==-1) //是作业队列的第一个
head=jobtable[head].next;
else
jobtable[t].next=jobtable[q].next;
//为作业q分配资源:分配主存空间;分配磁带机;分配打印机
memory=memory-jobtable[q].length;
tape=tape-jobtable[q].tape;
printer=printer-jobtable[q].printer;
printf("选中作业的作业名:%s\n",jobtable[q].name);
}
}while(q!=-1);
} //作业调度函数结束
main()
{char name[4];
int size,tcount,pcount,wtime,rtime;
int p;
//系统数据初始化
memory=65536;
tape=4;
printer=2;
head=-1;
printf("输入作业相关数据(以作业大小为负数停止输入):\n");
//输入数据,建立作业队列
printf("输入作业名、作业大小、磁带机数、打印机数、等待时间、估计执行时间\n"); scanf("%s%d%d %d %d %d",name,&size,&tcount,&pcount,&wtime,&rtime);
while(size!=-1)
{//创建JCB
if(jobcount<n)p=jobcount;
else { printf("无法再创建作业\n");
break;
}
jobcount++;
//填写该作业相关内容
strcpy(jobtable[p].name,name);
jobtable[p].length=size;
jobtable[p].printer=pcount;
jobtable[p].tape=tcount;
jobtable[p].runtime=rtime;
jobtable[p].waittime=wtime;
//挂入作业队列队首
jobtable[p].next=head;
head=p;
// 输入一个作业数据
printf("输入作业名、作业大小、磁带机数、打印机数、等待时间、估计执行时间\n"); scanf("%s%d%d%d%d%d",name,&size,&tcount,&pcount,&wtime,&rtime);
}//while
shedule( ); //进行作业调度
}//main( )函数结束。