实验1-批处理作业调度
实验1-批处理作业调度
批处理系统的作业调度1.实验目的加深对作业概念的理解;深入了解批处理系统如何组织作业、管理作业和调度作业;2.实验预备知识作业的概念;作业的创建;作业的调度。
3.实验内容编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。
实验具体包括:首先确定作业控制块的内容,作业控制块的组成方式;然后完成作业调度;最后编写主函数对所作工作进程测试。
4.提示与讲解操作系统根据允许并行工作的道数和一定的算法从系统中选取若干作业把它们装入主存储器,使它们有机会获得处理器运行,这项工作被称为“作业调度”。
实现这部分功能的程序就是“作业调度程序”。
作业调度的实现主要有两个问题,一个是如何将系统中的作业组织起来;另一个是如何进行作业调度。
为了将系统中的作业组织起来,需要为每个进入系统的作业建立档案以记录和作业相关的信息,例如作业名、作业所需资源、作业执行时间、作业进入系统的时间、作业信息在存储器中的位置、指向下一个作业控制块的指针等信息。
这个记录作业相关信息的数据块称为作业控制块(JCB),并将系统中等待作业调度的作业控制块组织成一个队列,这个队列称为后备队列。
一个作业全部信息进入系统后,就为其建立作业控制块,并挂入后备队列。
当进行作业调度时,从后备队列中查找选择作业。
由于实验中没有实际作业,作业控制块中的信息内容只使用了实验中需要的数据。
作业控制块中首先应该包括作业名;其次是作业所需资源,根据需要,实验中只包括需要主存的大小(采用可移动的动态分区方式管理主存,作业大小就是需要主存的大小)、需要打印机的数量和需要磁带机的数量;采用响应比作业调度算法,为了计算响应比,还需要有作业的估计执行时间、作业在系统中的等待时间;另外,指向下一个作业控制块的指针必不可少。
实验中,作业控制块及队列的数据结构定义如下。
typedef struct jcb{char name[4]; //作业名int length; //作业长度,所需主存大小int printer; //作业执行所需打印机的数量int tape; //作业执行所需磁带机的数量int runtime; //作业估计执行时间int waittime; //作业在系统中的等待时间int next; //指向下一个作业控制块的指针}JCB //作业控制块类型定义存放作业控制块的区域:#define n 10 //假定系统中可容纳的作业数量为nJCB jobtable[10]; //作业表int jobcount; //系统内现有作业数量将作业控制块组织成一个队列,实验中采用静态链表的方式模拟作业的后备队列,如图2.1所示。
操作系统作业调度实验报告
#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");
作业调度实验报告
一、根据调度算法设计流程图:实验
步骤
}
}
}
三、整合完成所有程序并实现作业调度(见源代码)。
四、进行调试阶段,对程序修改优化,进行数据测试。
五、实验结果分析
六、总结
实验
WindowsXP和CV++6.0集成开发环境
环境
实验运行的初始界面:
实验结
果与分
析
测试数据:
a1 1 2 a1
a2 2 3 a2
运行结果:
进行多次循环录入:返回算法选择界面:
测试数据:
b1 2 4 b1
b2 1 3 b2
运行结果:
实验分析和总结:
1)测试的数据必须是符合JCB模块中相同类型的,如在源码中式int类型的,而在测试的时候输入float类型就出错。
2)各个库函数的运用需要掌握相应的功能,否则会照成代码冗余、繁杂、不优化等各种问题。
3)通常在dos下运用的都是英文,而想要用汉字提示就必须考虑一些问题。
在源码中我们用制表符(\t)来控制提示,输出的数字是不能与之对齐的,所以我们要将“\t”改成空格。
4)这编写和调试程序时,为了尽快调通程序应该按照流程图的结构(保证流程图思路是对的情况下)来建立编程思路。
5)此程序也借用了现有的一些代码,并且它还不是最优化的,它还可以进行改进和优化,比如:在回调函数的引用时跳到了另一个页面,见下图:
继续Enter的时候就到下一页:
而不是在同一页面。
6)总之,在编程旅途中是一个很艰辛的过程,要在这里开拓一片蓝天就必须有孜孜不倦的精神。
实验一 处理机调度实验报告
实验一处理机调度一、实验内容选择一个调度算法,实现处理机调度。
二、实验目的多道系统中,当就绪进程数大于处理机数时,须按照某种策略决定哪些进程优先占用处理机。
本实验模拟实现处理机调度,以加深了解处理机调度的工作。
三、实验题目1、设计一个按优先权调度算法实现处理机调度的程序;2、设计按时间片轮转实现处理机调度的程序。
PCB内容要求:进程名/PID;要求运行时间(单位时间);优先权;状态:PCB指针;1、可随机输入若干进程,并按优先权排序;2、从就绪队首选进程运行:优先权-1要求运行时间-1要求运行时间=0时,撤销该进程3、重新排序,进行下轮调度;源代码:#include <stdio.h>#include <stdlib.h>#include <string.h>#include <windows.h>typedef struct pcb{char PID[50];int needTime;//需要运行时间int priority;//优先权char state[20];//进程状态struct pcb *next;}PCB;typedef struct{PCB* front;PCB* rear;}ProcessQueue;void SelectAlgorithm();void CreateQProcess(ProcessQueue &Q,char*,int time,int pri,char*);void ProcessSchedule();void InitQueue(ProcessQueue &Q);void visitQueue(ProcessQueue &Q);bool RunProcess(PCB* rp,ProcessQueue &Q);bool NonPreemptivePriority(ProcessQueue &Q);//非抢占式优先权调度void delProcess(PCB* delp);bool RunProcessPreem(PCB* rp,ProcessQueue &Q);//抢占式优先执行进程bool PreemptivePriority(ProcessQueue &Q);void RR(ProcessQueue &Q);int main(){int iSel;int i = 0;SelectAlgorithm();ProcessQueue readyQ;//就绪进程队列PCB newpcb;InitQueue(readyQ);printf("请选择调度算法:");do{scanf("%d",&iSel);} while (!(iSel == 1 || iSel == 2 || iSel == 3));while(i < 3){printf("请输入要创建的进程:\n");fflush(stdin);gets(newpcb.PID);fflush(stdin);scanf("%d",&newpcb.needTime);fflush(stdin);scanf("%d",&newpcb.priority);fflush(stdin);gets(newpcb.state);fflush(stdin);CreateQProcess(readyQ,newpcb.PID,newpcb.needTime,newpcb.priority,newpcb.state);printf("创建了一个进程\n");++i;}visitQueue(readyQ);//显示的是各个进程的优先权switch(iSel){case 1:while(NonPreemptivePriority(readyQ));//非抢占优先权调度break;case 2:PreemptivePriority(readyQ);//抢占式优先权调度break;case 3:RR(readyQ);break;}return 0;}void SelectAlgorithm(){printf("1.非抢占式优先权调度\n");printf("2.抢占式优先权调度\n");printf("3.时间片轮转调度\n");}void InitQueue(ProcessQueue &Q)//初始化进程队列{Q.front = Q.rear = (PCB*)malloc(sizeof(PCB));if(!Q.front) exit(-1);Q.front->next = NULL;}void CreateQProcess(ProcessQueue &Q,char* pid,int time,int pri,char* st)//指定进程入就绪队列,将优先权高的插在队列前面{PCB* p = (PCB*)malloc(sizeof(PCB));if(!p) exit(-1);strcpy(p->PID,pid); p->needTime = time;p->priority = pri; strcpy(p->state,st);p->next = NULL;PCB* q = Q.front->next, *old = Q.front;if(!q)//如果原队列为空{Q.rear->next = p;Q.rear = p;//q == NULL}else//如果原队列不为空{for(;q != NULL;){if(p->priority > q->priority){old->next = p;p->next = q;return;}q = q->next;old = old->next;if(q == NULL){Q.rear->next = p;Q.rear = q;//q == NULL}}}}void ProcessSchedule(){}void visitQueue(ProcessQueue &Q)//访问进程队列{PCB* p = (PCB*)malloc(sizeof(PCB));if(!p) exit(-1);p = Q.front->next;while(p != NULL){printf("%d,",p->priority);p = p->next;}printf("\n");int i = 0;}bool PreemptivePriority(ProcessQueue &Q){PCB* rprocess;if(!Q.front->next){printf("就绪队列中没有进程可以调度!\n");return false;}else{rprocess = Q.front->next;//选择优先权最高的进程Q.front->next = Q.front->next->next;//将进程移除就绪队列while(rprocess != NULL)//抢占式优先调度{RunProcessPreem(rprocess,Q);if(rprocess->needTime == 0){delProcess(rprocess);if((rprocess = Q.front->next) == NULL){printf("就绪队列中没有进程可以调度!\n");return false;}else{Q.front->next = Q.front->next->next;continue;}}if(Q.front->next != NULL){if(rprocess->priority < Q.front->next->priority)//判断运行了1个时间后还是否具有最高优先权{/*rprocess->next = Q.front->next->next;//正在运行中的进程因为优先权降低,重新进入就绪队列temp = Q.front->next;Q.front->next = rprocess;rprocess = temp;//rprocess保存运行进程*/CreateQProcess(Q,rprocess->PID,rprocess->needTime,rprocess->priority,rprocess->state);//正在运行中的进程因为优先权降低,重新进入就绪队列rprocess = Q.front->next;Q.front->next = Q.front->next->next;}}}}return true;}bool NonPreemptivePriority(ProcessQueue &Q)//非抢占式优先权调度{PCB* rprocess;//存放要调度运行的进程if(!Q.front->next){printf("就绪队列中没有进程可以调度!\n");return false;}else{rprocess = Q.front->next;Q.front->next = Q.front->next->next;//已经调度,从就绪队列中删除进程if(RunProcess(rprocess,Q)){delProcess(rprocess);printf("就绪队列状态:\n");visitQueue(Q);}return true;}}bool RunProcess(PCB* rp,ProcessQueue &Q)//执行进程{while(rp->needTime){printf("进程%s正在运行...\n",rp->PID);printf("PID[50]\tneedTime\tpriority\tstate[20]\n");printf("%s\t%d\t\t%d\t\t%s\n",rp->PID,rp->needTime,rp->priority,rp->state);Sleep(1000);--rp->needTime;}return true;}bool RunProcessPreem(PCB* rp,ProcessQueue &Q)//抢占式优先,RR执行进程{printf("进程%s正在运行...\n",rp->PID);printf("PID[50]\tneedTime\tpriority\tstate[20]\n");printf("%s\t%d\t\t%d\t\t%s\n",rp->PID,rp->needTime,rp->priority,rp->state);Sleep(1000);--rp->needTime;--rp->priority;return true;}void delProcess(PCB* delp)//撤销进程{free(delp);}void RR(ProcessQueue &Q){PCB* running = Q.front->next;PCB* old = Q.front;while(Q.front->next != NULL){if(running){RunProcessPreem(running,Q);if(running->needTime == 0)//撤销进程{old->next = running->next;delProcess(running);running = old->next;continue;}old = old->next;running = running->next;}else{old = Q.front;running = old->next;}}printf("就绪队列中没有进程可以调度!\n");}以下是使用时间片轮转算法的一次执行:选择算法3:进程输入,此处输入1,1,1,1,2,2,2,2,3,3,3,3测试。
批处理系统的作业调度
实验批处理系统的作业调度一、实验目的(1)加深对作业概念的理解;(2)深入了解批处理系统如何组织作业、管理作业和调度作业。
二、预备知识(1)批处理系统的概念;批处理系统,又名批处理操作系统。
批处理是指用户将一批作业提交给操作系统后就不再干预,由操作系统控制它们自动运行。
这种采用批量处理作业技术的操作系统称为批处理操作系统。
批处理操作系统分为单道批处理系统和多道批处理系统。
批处理操作系统不具有交互性,它是为了提高CPU的利用率而提出的一种操作系统。
1.作用:大家知不知道默认共享这回事?这东西用不着的地方可就不是好东西了.所以就要删掉.但这东西是每次系统重起后都会重新创建的.所以每次都要重新打开cmd重新删掉一下.极为麻烦.但有了批处理文件就不一样了,先把命令输入到批处理文件中,然后加入到启动项中,每次启动就会自动运行,免去了每次输入命令的麻烦.(2).如何创建批处理文件?不要听了批处理文件就感到很神气,其实这东西很简单的.你用过记事本没有?用过?好的.将记事本打开,什么都不用写,然后选择文件,保存.保存类型选择所有文件,文件名则命名为*.bat 这个*代表是文件名,你可以随便的起.保存好之后,看看你保存的地方,会出现一个白色窗口里有个黄色齿轮的图标.这东西就是你创建的批处理文件,双击他就可以运行,但他现在由于里面没有输入任何命令,所以他运行了并不会做任何事情.当我们想往这个*.bat文件中添加东西时,只要右键选择他,然后选择编辑,就可以打开记事本往内输入命令了.3.批处理文件中的命令是什么?批处理文件中的命令暂时先可以理解为dos命令,等稍后深入理解了以后再进行解释.批处理顾名思义就是一大堆东西堆在一起处理.换句话说就是往里面写一条条dos命令,然后按顺序挨个执行,效果跟你在cmd里敲dos命令是一个效果.只不过用批处理写好之后,要运行只要双击下就可以运行了.而不用再一遍一遍的重复的往里面打命令.这就是批处理文件的好处.(2)批处理系统的调度。
操作系统实验报告作业调度
操作系统实验报告作业调度操作系统实验报告:作业调度引言作业调度是操作系统中的重要部分,它负责管理和调度系统中的各种作业,以最大化系统资源的利用率和提高作业的执行效率。
在本次实验中,我们将探讨作业调度的基本原理和实现方法,并通过实验验证其效果。
实验目的本次实验的主要目的是通过实际操作,了解作业调度的基本原理和实现方法,掌握作业调度的相关算法,并通过实验验证其有效性。
实验内容1. 实现作业调度的基本算法在本次实验中,我们将实现作业调度的基本算法,包括先来先服务(FCFS)、最短作业优先(SJF)、优先级调度(Priority Scheduling)和多级反馈队列调度(Multilevel Feedback Queue Scheduling)等。
通过编写代码,模拟这些算法的执行过程,并观察它们的效果。
2. 实验验证我们将设计一些测试用例,通过模拟作业的执行过程,分别使用不同的作业调度算法,并比较它们的执行效果。
通过实验验证,我们将得出不同算法的优劣势,并分析其适用场景。
实验结果经过实验验证,我们得出以下结论:1. 先来先服务(FCFS)算法适用于作业执行时间相对均匀的情况,但可能会导致平均等待时间较长。
2. 最短作业优先(SJF)算法能够最大程度地减少平均等待时间,但可能会出现作业饥饿现象。
3. 优先级调度(Priority Scheduling)算法能够根据作业的优先级进行调度,适用于有明确优先级需求的情况。
4. 多级反馈队列调度(Multilevel Feedback Queue Scheduling)算法能够根据作业的执行情况动态调整优先级,适用于各种类型的作业。
结论作业调度是操作系统中的重要组成部分,不同的作业调度算法适用于不同的场景。
通过本次实验,我们深入了解了作业调度的基本原理和实现方法,掌握了不同算法的优劣势,并通过实验验证了它们的有效性。
这将对我们进一步深入学习操作系统和提高系统性能有着重要的意义。
操作系统原理实验教学大纲(本科)-2013
《操作系统原理》实验教学大纲一、实验教学内容与基本要求实验一 批处理系统的作业调度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 实验内容编写程序完成页式存储管理中地址转换过程和模拟缺页中断的处理。
实验具体包括:首先对给定的地址进行地址转换工作,若发生缺页则先进行缺页中断处理,然后再进行地址转换;最后编写主函数对所做工作进行测试。
实验一 处理机调度实验报告
实验一处理机调度实验报告一、实验目的处理机调度是操作系统中的一个重要组成部分,其目的是合理地分配处理机资源,以提高系统的性能和效率。
本次实验的主要目的是通过模拟处理机调度算法,深入理解不同调度算法的工作原理和性能特点,并能够对它们进行比较和分析。
二、实验环境本次实验使用了以下软件和工具:1、操作系统:Windows 102、编程语言:Python3、开发环境:PyCharm三、实验内容1、先来先服务(FCFS)调度算法先来先服务调度算法按照作业或进程到达的先后顺序进行调度。
即先到达的作业或进程先得到处理机的服务。
2、短作业优先(SJF)调度算法短作业优先调度算法优先调度运行时间短的作业或进程。
在实现过程中,需要对作业或进程的运行时间进行预测或已知。
3、高响应比优先(HRRN)调度算法高响应比优先调度算法综合考虑作业或进程的等待时间和运行时间。
响应比的计算公式为:响应比=(等待时间+要求服务时间)/要求服务时间。
4、时间片轮转(RR)调度算法时间片轮转调度算法将处理机的时间分成固定大小的时间片,每个作业或进程在一个时间片内运行,当时间片用完后,切换到下一个作业或进程。
四、实验步骤1、设计数据结构为了表示作业或进程,设计了一个包含作业或进程 ID、到达时间、运行时间和等待时间等属性的数据结构。
2、实现调度算法分别实现了上述四种调度算法。
在实现过程中,根据算法的特点进行相应的处理和计算。
3、模拟调度过程创建一组作业或进程,并按照不同的调度算法进行调度。
在调度过程中,更新作业或进程的状态和相关时间参数。
4、计算性能指标计算了平均周转时间和平均带权周转时间等性能指标,用于评估不同调度算法的性能。
五、实验结果与分析1、先来先服务(FCFS)调度算法平均周转时间:通过计算所有作业或进程的周转时间之和除以作业或进程的数量,得到平均周转时间。
在 FCFS 算法中,由于按照到达顺序进行调度,可能会导致长作业或进程长时间占用处理机,从而使平均周转时间较长。
批处理作业调度(回溯)
批处理作业调度(回溯).算法设计例题:批处理作业调度(回溯)memory limit: 5000KB time limit: 2000MSaccept: 13 submit: 33Description给定n个作业的集合J = { J1,J2,…,Jn }。
每一个作业Ji都有两项任务分别在两台机器上完成。
每个作业必须先由机器1处理,然后由机器2处理。
作业Ji需要机器j的处理时间为tji,其实i=1,2,…,n,j=1,2。
对于一个确定的作业调度,设Fji是作业i在机器j上完成处理的时间。
所有作业在机器2上完成处理的时间和称为该作业调度的完成时间和。
批处理作业调度问题要求对于给定的n个作业,制定最佳作业调度方案,使其完成时间和达到最小。
Input输入的第一个为测试样例的个数T(T < 120 ),接下来有T个测试样例。
每个测试样例的第一行是作业个数n(n ≤7 ),接下来n行,每行两个整数t1i 和t2i ,分别表示当前作业在机器1和机器2上的处理时间。
(0 ≤t1i , t2i ≤100 )Output对应每个测试样例输出两行,第一行格式为"Case #: M",其中'#'表示第几个测试样例(从1开始计),M为最佳作业调度的时间和。
第二行为n个以空格分隔的整数,表示最佳作业调度方案中各作业执行顺序的序号。
Sample Input132 13 12 3Sample OutputCase 1: 181 3 2源代码:#include<cstdio>#include<cstring>class FlowShop{public:int n, //作业数f1, //机器1完成处理时间f, //完成时间和bestf, //当前最优值m[35][3], //各作业所需处理时间x[35], //当前作业调度bestx[35], //当前最优作业调度f2[35]; //机器2完成处理时间void swap(int &a,int &b){int c=a;a=b;b=c;}int play(){f1=0;f=0;bestf=0x3f3f3f3f;int i;for(i=0;i<=n;++i)x[i]=i,f2[i]=0;backtrack(1);return bestf;}void backtrack(int i){if(i>n){for(int j=1;j<=n;++j)bestx[j]=x[j];bestf=f;}else{for(int j=i;j<=n;++j){f1+=m[x[j]][1];f2[i]=((f2[i-1]>f1)?f2[i-1]:f1)+m[x[j]][2];f+=f2[i];if(f<bestf){swap(x[i],x[j]);backtrack(i+1);swap(x[i],x[j]);}f1-=m[x[j]][1];f-=f2[i];}}}};int main(){int T,cas=1;scanf("%d",&T);while(T--){FlowShop p;scanf("%d",&p.n);int i;for(i=1;i<=p.n;++i)scanf("%d %d",&p.m[i][1],&p.m[i][2]);printf("Case %d: %d\n",cas++,p.play());for(i=1;i<=p.n;++i){if(i!=1) putchar(' ');printf("%d",p.bestx[i]);}puts("");}return 0;}。
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作业证在运行,估计其运行情况: 开始运宜时刻:。
操作系统实验报告作业调度
操作系统实验报告作业调度操作系统实验报告:作业调度引言:操作系统是计算机系统中最核心的软件之一,它负责管理计算机的资源,为用户提供良好的使用环境。
在操作系统中,作业调度是非常重要的一部分,它决定了计算机如何合理地分配和调度各个作业的执行顺序,以提高计算机的效率和性能。
本实验报告将介绍作业调度的概念、调度算法以及实验结果。
一、作业调度的概念作业调度是指根据一定的策略和算法,将就绪队列中的作业按照一定的顺序分配给处理器,使得计算机系统能够充分利用资源,提高系统的吞吐量和响应时间。
作业调度的目标是实现公平性、高效性和平衡性。
二、作业调度的算法1. 先来先服务(FCFS)调度算法FCFS调度算法是最简单的调度算法之一,它按照作业的到达顺序进行调度,先到达的作业先执行。
这种算法的优点是简单易实现,但是可能会导致长作业等待时间过长,造成资源浪费。
2. 最短作业优先(SJF)调度算法SJF调度算法是根据作业的执行时间来进行调度,执行时间短的作业先执行。
这种算法能够最大程度地减少平均等待时间,提高系统的响应速度,但是可能会导致长作业长时间等待。
3. 优先级调度算法优先级调度算法是根据作业的优先级来进行调度,优先级高的作业先执行。
这种算法可以根据不同的需求设置不同的优先级,但是可能会导致低优先级的作业长时间等待。
4. 时间片轮转调度算法时间片轮转调度算法是将处理器的执行时间划分为多个时间片,每个作业在一个时间片内执行,时间片用完后,将处理器分配给下一个作业。
这种算法可以实现公平性,但是可能会导致长作业等待时间过长。
三、实验结果与分析在本次实验中,我们使用了不同的作业调度算法,并对其进行了性能测试。
测试结果显示,FCFS算法在平均等待时间方面表现较差,而SJF算法和优先级调度算法在平均等待时间方面表现较好。
时间片轮转调度算法能够实现公平性,但是可能会导致长作业等待时间过长。
结论:作业调度是操作系统中的重要组成部分,合理的作业调度算法能够提高计算机系统的效率和性能。
操作系统 批处理系统作业调度实验报告
操作系统批处理系统作业调度实验报告批处理系统的作业调度实验报告年级 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. 本程序采用响应比高者优先算法进行作业调度。
实验一 编程模拟处理机调度
一、实验教学内容与基本要求(时间: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版)操作系统作业调度实验报告-多道批处理
计算机学院计算机科学与技术专业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
实验批处理系统的作业调度一、实验目的(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为输入结束。
操作系统实验报告-作业调度
作业调度一、实验目的1、对作业调度的相关内容作进一步的理解。
2、明白作业调度的主要任务。
3、通过编程掌握作业调度的主要算法。
二、实验内容及要求1、对于给定的一组作业, 给出其到达时间和运行时间,例如下表所示:作业名 A B C D E F到达时间0 2 5 5 12 15服务时间 6 50 20 10 40 82、分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。
3、计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。
三、主要算法流程图开始响应比高者优先短作业优先先来先服务算法生成调度顺序队列计算平均周转时间及平均带权周转时间结束退出系统YN四、测试数据及运行结果测试数据workA={'作业名':'A','到达时间':0,'服务时间':6} workB={'作业名':'B','到达时间':2,'服务时间':50} workC={'作业名':'C','到达时间':5,'服务时间':20} workD={'作业名':'D','到达时间':5,'服务时间':10} workE={'作业名':'E','到达时间':12,'服务时间':40} workF={'作业名':'F','到达时间':15,'服务时间':8}运行结果先来先服务算法调度顺序:['A', 'B', 'C', 'D', 'E', 'F'] 周转时间:74.1666666667 带权周转时间:4.83333333333短作业优先算法调度顺序:['A', 'D', 'F', 'C', 'E', 'B']周转时间:44.8333333333带权周转时间:1.166********响应比高者优先算法调度顺序:['A', 'D', 'F', 'E', 'C', 'B']周转时间:48.1666666667带权周转时间:1.5五、代码#encoding=gbkworkA={'作业名':'A','到达时间':0,'服务时间':6,'结束时间':0,'周转时间':0,'带权周转时间':0}workB={'作业名':'B','到达时间':2,'服务时间':50}workC={'作业名':'C','到达时间':5,'服务时间':20}workD={'作业名':'D','到达时间':5,'服务时间':10}workE={'作业名':'E','到达时间':12,'服务时间':40}workF={'作业名':'F','到达时间':15,'服务时间':8}list1=[workB,workA,workC,workD,workE,workF]list2=[workB,workA,workC,workD,workE,workF]list3=[workB,workA,workC,workD,workE,workF]#先来先服务算法def fcfs(list):resultlist = sorted(list, key=lambda s: s['到达时间'])return resultlist#短作业优先算法def sjf(list):time=0resultlist=[]for work1 in list:time+=work1['服务时间']listdd=[]ctime=0for i in range(time):for work2 in list:if work2['到达时间']<=ctime:listdd.append(work2)if len(listdd)!=0:li = sorted(listdd, key=lambda s: s['服务时间'])resultlist.append(li[0])list.remove(li[0])ctime+=li[0]['服务时间']listdd=[]return resultlist#响应比高者优先算法def hrrn(list):time=0resultlist=[]for work1 in list:time+=work1['服务时间']listdd=[]ctime=0for i in range(time):for work2 in list:if work2['到达时间']<=ctime:work2['等待时间']=ctime-work2['到达时间']listdd.append(work2)if len(listdd)!=0:li = sorted(listdd, key=lambda s: (s['等待时间']+s['服务时间'])/s['服务时间'])resultlist.append(li[-1])list.remove(li[-1])ctime+=li[-1]['服务时间']listdd=[]return resultlist#调度顺序def shunxu(resultlist,miaoshu):print(miaoshu)ddsx=[]for work in resultlist:for d,x in work.items():if d.decode('gb2312')==u'作业名':ddsx.append(x)#print d.decode('gb2312')+":"+str(x) print(u'调度顺序:'+str(ddsx))turnaroundTime(resultlist)#平均周转时间及平均带权周转时间def turnaroundTime(resultlist):time=0for work in resultlist:work['结束时间']=work['服务时间']+timetime=work['结束时间']work['周转时间']=work['结束时间']-work['到达时间']work['带权周转时间']=work['周转时间'] / work['服务时间'] zzsj=0dqzzsj=0for work in resultlist:zzsj+=work['周转时间']dqzzsj+=work['带权周转时间']print('周转时间:'+str(zzsj*1.0/len(resultlist)))print('带权周转时间:'+str(dqzzsj*1.0/len(resultlist)))print('')shunxu(fcfs(list1),'先来先服务算法') shunxu(sjf(list2),'短作业优先算法') shunxu(hrrn(list3),'响应比高者优先算法')。
操作系统之实验-作业调度
作业调度一、实习内容模拟批处理多道操作系统的作业调度。
二、实习目的每个用户请求计算机的一个计算任务叫做一个作业。
一个作业从初始数据到得到计算结果,要经过若干个步骤的相继执行。
例如,编辑、编译、运行等,其中每一个步骤称作一个作业步。
用户向系统提出作业加工的方式称作业控制方式,作业控制方式有两种:终端控制方式(又称直接控制方式或联机控制方式)和批处理控制方式(又称自动控制方式或脱机控制方式)。
在批处理控制方式下,用户采用系统提供的作业控制语言(JCL)写好作业说明书,说明作业加工的步骤。
操作员把一批作业组织成输入流,通过“预输入”手段使每个作业的信息(包括作业说明书、源程序、初始数据等)暂存在辅助存储器的“输入井”中。
批处理多道操作系统的作业管理有两个任务:作业调度和作业控制。
采用多道程序设计方法的操作系统,在系统中要经常保留多个运行的作业,以提高系统效率。
作业调度从系统已接纳的暂存在输入井中的一批作业中挑选出若干个可运行的作业,并为这些被选中的作业分配所需的系统资源。
对被选中运行的作业,必须按照它们各自的作业说明书规定的步骤进行控制。
本实习要求学生模拟作业调度的实现,了解作业调度在操作系统中的作用。
三、实习题目采用先来先服务算法和运行时间最短者优先算法模拟设计作业调度程序。
【提示】(1)作业调度程序负责从输入井选择若干个作业进入主存,为它们分配必要的资源,当它们能够被进程调度选中时,就可以占用处理器运行,作业调度选择一个作业的必要条件是系统中现有的尚未分配的资源可以满足该作业的资源需求。
但有进系统中现有的尚未分配的资源既可满足某个作业的要求也可以满足其它一些作业的要求,那么,作业调度必须按照一定的算法在这些作业中作出选择。
先来先服务算法是按照作业进入输入井的先后次序来挑选作业,先进入输入井的作业优先被挑选,当系统中现有的尚未分配的资源不能满足先进入输入井的作业时,那么顺序挑选后面的作业。
运行时间最短者优先算法总是按作业要求能满足的作业先进入主存执行。
操作系统实验报告作业调度
操作系统实验报告:作业调度1. 引言作业调度是操作系统中的一个重要概念,它涉及到如何合理地安排计算机系统中的作业执行顺序,以最大程度地提高系统的效率和性能。
本文将介绍作业调度的基本概念和主要算法,以及在实验中的应用。
2. 作业调度的概念作业调度是指根据一定的策略和算法,按照一定的顺序从作业队列中选取作业,将其分配给可用资源来执行的过程。
作业调度的目标是实现公平、高效的任务分配,以提高系统的整体性能。
3. 作业调度算法3.1 先来先服务(FCFS)先来先服务是最简单的作业调度算法,即按照作业提交的顺序来执行。
当一份作业到达系统后,它将被放入作业队列的末尾。
一旦当前执行的作业完成,系统将选择队列中的下一个作业来执行。
3.2 短作业优先(SJF)短作业优先算法是根据作业的执行时间来进行调度,执行时间越短的作业优先级越高。
当一个作业进入系统时,系统会检查队列中的所有作业,并选择执行时间最短的作业来执行。
3.3 优先级调度优先级调度算法是根据作业的优先级来进行调度,优先级越高的作业优先级越高。
每个作业都会被分配一个优先级值,系统会按照优先级从高到低的顺序来执行作业。
3.4 时间片轮转调度时间片轮转调度算法将作业分为多个时间片,每个时间片的执行时间相等。
当一个作业进入系统时,系统会分配给它一个时间片,如果在时间片内作业没有完成,则将其放回队列的末尾,并执行下一个作业。
4. 实验中的应用在操作系统实验中,作业调度是一个重要的实验内容。
通过实验,我们可以深入了解不同调度算法的特点和适用场景。
实验中,我们可以使用模拟器来模拟作业调度的过程。
我们可以创建一个作业队列,然后使用不同的调度算法来执行这些作业,并记录它们的执行时间和系统的吞吐量。
通过实验,我们可以比较不同算法在不同场景下的表现,选择最适合当前系统的作业调度算法。
5. 结论作业调度是一个重要的操作系统概念,它决定了系统的性能和效率。
在本文中,我们介绍了作业调度的基本概念和常用算法,并讨论了在实验中的应用。
操作系统实验报告-批处理系统的作业调度
#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. 实验环境•操作系统:Linux•编程语言:Python•实验工具:CPU模拟器3. 实验原理作业调度是操作系统中的一个重要环节,主要负责将用户提交的作业按照一定的策略分配到CPU上执行。
作业调度的主要目标是提高CPU的利用率,缩短作业的平均等待时间,提高系统的吞吐量。
常用的作业调度算法有先来先服务(FCFS)、短作业优先(SJF)、最短剩余时间优先(SRT)等。
4. 实验内容本次实验主要分为两个部分:一是实现作业调度算法,二是对不同算法进行性能分析。
4.1 作业调度算法实现以先来先服务(FCFS)算法为例,实现作业调度如下:```pythonclass Job:def __init__(self, job_id, arrival_time, execute_time):self.job_id = job_idself.arrival_time = arrival_timeself.execute_time = execute_timeclass JobScheduler:def __init__(self):self.jobs = []def add_job(self, job):self.jobs.append(job)def schedule(self):start_time = 0finish_time = 0for job in self.jobs:if job.arrival_time >= start_time:start_time = job.arrival_timefinish_time = start_time + job.execute_timeprint(f"Job {job.job_id} arrives at {start_time} and finishes a t {finish_time}")start_time = finish_timeif name== “main”:scheduler = JobScheduler()scheduler.add_job(Job(1, 0, 5))scheduler.add_job(Job(2, 1, 3))scheduler.add_job(Job(3, 3, 8))scheduler.schedule()4.2 性能分析通过对不同作业调度算法的模拟运行,分析其性能指标,如平均等待时间、平均响应时间、吞吐量等。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
批处理系统的作业调度
1.实验目的
加深对作业概念的理解;
深入了解批处理系统如何组织作业、管理作业和调度作业;
2.实验预备知识
作业的概念;
作业的创建;
作业的调度。
3.实验内容
编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。
实验具体包括:首先确定作业控制块的内容,作业控制块的组成方式;然后完成作业调度;最后编写主函数对所作工作进程测试。
4.提示与讲解
操作系统根据允许并行工作的道数和一定的算法从系统中选取若干作业把它们装入主存储器,使它们有机会获得处理器运行,这项工作被称为“作业调度”。
实现这部分功能的程序就是“作业调度程序”。
作业调度的实现主要有两个问题,一个是如何将系统中的作业组织起来;另一个是如何进行作业调度。
为了将系统中的作业组织起来,需要为每个进入系统的作业建立档案以记录和作业相关的信息,例如作业名、作业所需资源、作业执行时间、作业进入系统的时间、作业信息在存
储器中的位置、指向下一个作业控制块的指针等信息。
这个记录作业相关信息的数据块称为作业控制块(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; //系统内现有作业数量
将作业控制块组织成一个队列,实验中采用静态链表的方式模拟作业的后备队列,如图2.1所示。
作业队列头指针定义:
int *head;
图2.1 采用响应比高者优先算法的作业调度程序的流程图
确定作业组织方式之后,就要开始考虑如何进行作业调度。
尽管不同的计算机系统可以采用不同的调度原则和调度算法,但是都必须遵循一个必要条件,即系统现有的尚未分配的
资源可以满足被选作业的资源要求。
就是说,所有的作业调度都是按照一定的算法,从满足必要条件的作业中选择一部分作业装入主存储器。
实验中,主存采用可移动的动态分区管理方法,即只要主存空闲区总和比作业大就可以满足作业对主存的需求;对打印机和磁带机这两种独占型设备采用静态分配法,即作业执行前必须获得所需资源,并且执行完才归还。
常用的作业调度算法有先来先服务算法、计算时间短的作业优先算法、响应比高者优先算法、优先数调度算法和均衡调度算法。
实验中采用响应比高者优先算法,响应比的定义为:响应比=作业的等待时间/作业估计执行时间
采用响应比高者优先调度算法,进行调度时必须计算出系统中的所有满足必要条件作业的响应比;从中选择响应比最高的一个作业装入主存储器、分配资源,由于是实验,所以就用将作业的作业控制块出队,并输出作业的作业名代替装入主存储器,同时修改系统的资源数量;用同样方法选择第二个、第三个……直到不再有满足必要条件的作业。
采用响应比高者优先算法的作业调度程序流程图如图2.1所示。
模拟程序中,首先要假设系统的资源情况,假设系统资源只有主存(memory)64MB(以KB为单位分配)、磁带机(tape)4台和打印机(printer)2台;然后,手工输入某个时刻系统中的各个作业情况;最后进行作业调度,并将结果输出。
5.课外题
将上述实验中的作业调度算法改为短作业优先调度算法重新完成上述工作。
6.参考程序
#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].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;
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( )函数结束。