操作系统课程设计---作业调度模拟
操作系统课程设计报告-进程调度的模拟实现
操作系统课程设计报告专业计算机科学与技术学生姓名班级学号指导教师完成日期博雅学院ﻬ题目:进程调度的模拟实现的模拟实现一、设计目的本课程设计是学习完“操作系统原理”课程后进行的一次全面的综合训练，通过课程设计，更好地掌握操作系统的原理及实现方法，加深对操作系统基础理论和重要算法的理解,加强学生的动手能力。
在多道程序和多任务系统中,系统内同时处于就绪状态的进程可能有若干个。
也就是说能运行的进程数大于处理机个数。
为了使系统中的进程能有条不紊地工作,必须选用某种调度策略，选择一进程占用处理机。
要求学生设计一个模拟处理机调度算法,以巩固和加深处理机调度的概念.二、设计内容1)概述选择一个调度算法，实现处理机调度。
设计要求:１)进程调度算法包括：时间片轮转法，短作业优先算法，动态优先级算法。
2)可选择进程数量3)本程序包括三种算法,用C或Ｃ++语言实现，执行时在主界面选择算法(可用函数实现），进入子页面后输入进程数,（运行时间，优先数由随机函数产生),执行，显示结果。
调度时总是选取优先数最大的进程优先运行２．每个进程的优先数，运行时间，由程序任意指定.3．为了调度方便,把进程按给定优先级(动态优先级算法中）从小到大排成一个队列。
按给定运行时间（短作业优先）从小到大排成一个队列用一个变量作为队首指针,指向队列的第一个进程。
4．处理机调度总是选队首进程运行。
由于本实验是模拟处理机调度，所以被选中的进程并不实际的启动运行，而是执行:优先数－1（动态优先级算法中)要求运行时间－1来模拟进程的一次运行。
5.进程运行一次后，若要求运行时间不等于０,则再将它加入队列（动态优先级算法中:按优先数大小插入.)，且改变队首指针：若要求运行时间=0，则把它的状态改为完成（C)状态,且退出队列。
（5)对于遇到优先数一致的情况,采用FIFO策略解决.3。
概要设计(1)本程序用两种算法对五个进程进行调度,每个进程可有三个状态,并假设初始状态为就绪状态。
操作系统课程设计报告-进程调度算法模拟
1．课程设计的目的《操作系统原理》课程设计我们专业实践性环节之一，是学习完《操作系统原理》课程后进行的一次较全面的综合练习。
其目的在于加深对操作系统的理论、方法和基础知识的理解，掌握操作系统结构、实现机理和各种典型算法，系统地了解操作系统的设计和实现思路，培养学生的系统设计能力，并了解操作系统的发展动向和趋势。
2．课程设计的内容及要求先来先服务、短作业优先、时间片轮转、基于静态优先级的调度，基于高响应比优先的动态优先级调度算法实现，能够输出调度情况，并计算周转时间和平均周转时间。
要求使用链表，进程个数由用户提供，按照进程的实际个数生成PCB，程序能够让用户选择使用哪种调度算法，能够在Linux环境运行并验证结果。
程序要考虑用户界面的友好性和使用方便性。
进程基本信息可从文件读入，也可手动输入。
3、设计原理3.1先来先服务调度算法每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源创建进程，然后放入就绪队列3.2短作业优先调度算法短作业优先调度算法是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。
3.3时间片轮转调度算法系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。
时间片的大小从几ms到几百ms。
当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。
3.4静态优先级调度算法把处理机分配给优先级最高的进程，使之执行。
但在其执行期间，只要出现了另一个比其优先级更高的进程，调度程序就将处理机分配给新到的优先级最高的进程。
这样就可以保证紧迫性作业优先运行。
3.5最高响应比优先的动态优先级调度算法优先权调度算法是为了照顾紧迫型作业，使之在进入系统后便获得优先处理，引入最高优先权优先调度算法。
操作系统——作业调度
操作系统——作业调度实验⼆作业调度模拟程序⼀、⽬的和要求 1. 实验⽬的 （1）加深对作业调度算法的理解； （2）进⾏程序设计的训练。
2．实验要求 ⽤⾼级语⾔编写⼀个或多个作业调度的模拟程序。
单道批处理系统的作业调度程序。
作业⼀投⼊运⾏，它就占有计算机的⼀切资源直到作业完成为⽌，因此调度作业时不必考虑它所需要的资源是否得到满⾜，它所运⾏的时间等因素。
作业调度算法： 1) 采⽤先来先服务（FCFS）调度算法，即按作业到达的先后次序进⾏调度。
总是⾸先调度在系统中等待时间最长的作业。
2) 短作业优先 (SJF) 调度算法，优先调度要求运⾏时间最短的作业。
3) 响应⽐⾼者优先(HRRN)调度算法，为每个作业设置⼀个优先权(响应⽐)，调度之前先计算各作业的优先权，优先数⾼者优先调度。
RP (响应⽐)＝作业周转时间 / 作业运⾏时间=1+作业等待时间/作业运⾏时间每个作业由⼀个作业控制块JCB表⽰，JCB可以包含以下信息：作业名、提交（到达）时间、所需的运⾏时间、所需的资源、作业状态、链指针等等。
作业的状态可以是等待W（Wait）、运⾏R（Run）和完成F（Finish）三种之⼀。
每个作业的最初状态都是等待W。
⼀、模拟数据的⽣成 1．允许⽤户指定作业的个数（2-24），默认值为5。
2. 允许⽤户选择输⼊每个作业的到达时间和所需运⾏时间。
3.（**）从⽂件中读⼊以上数据。
4.（**）也允许⽤户选择通过伪随机数指定每个作业的到达时间（0-30）和所需运⾏时间（1-8）。
⼆、模拟程序的功能 1．按照模拟数据的到达时间和所需运⾏时间，执⾏FCFS, SJF和HRRN调度算法，程序计算各作业的开始执⾏时间，各作业的完成时间，周转时间和带权周转时间（周转系数）。
2. 动态演⽰每调度⼀次，更新现在系统时刻，处于运⾏状态和等待各作业的相应信息（作业名、到达时间、所需的运⾏时间等）对于HRRN算法，能在每次调度时显⽰各作业的响应⽐R情况。
兰州理工大学—操作系统课设—作业调度模拟程序说明书
目录前摘正言 (2)要 (3)文 (4)1.2.3.4.5.6.设计思想 (4)算法用到的主要数据结构（采用类C语言定义） (5)相关的各模块的伪码算法 (5)调试分析 (8)测试结果 (14)源程序（带注释） (15)总结 (24)参考文献 (25)致谢 (26)前言每个用户请求计算机计算的一个计算任务叫做一个作业。
一个作业从输入初始数据到得到计算结果，要经过若干个步骤的相继执行。
例如：编辑、编译、运行等，其中每一个步骤称作一个作业步。
用户向系统提出作业加工步骤的方式称作业控制方式，作业控制方式有两种：终端控制方式（又称直接控制方式或联机控制方式）和批处理控制方式（又称自动控制方式或脱机控制方式）。
在批处理控制方式下，用户采用系统提供的作业控制语言（JCL）写好作业说明书，说明作业加工的步骤。
操作员把一批作业组织成输入流，通过“预输入”手段使每个作业的信息（包括作业说明书、源程序、初始数据等）暂存在辅助存储器的“输入井”中。
批处理多道程序操作系统的作业管理有两个任务：作业调度和作业控制。
采用多道程序设计方法的操作系统，在系统中要经常用保留多个运行的作业，以提高系统效率。
作业调度从系统已接纳的作业分配所需的系统资源。
对被选中运行的作业按照它们各自的作业说明书中规定的步骤进行控制。
摘要对于成批进入系统的作业来说，根据作业控制块信息，按照一定的策略选取若干个作业使它们可以去获得处理器运行，这项工作称为作业调度。
而对于每个用户来说，总希望自己的作业的周转时间尽可能小，最理想的情况是进入系统后能立即运行，即希望作业的周转时间等于执行时间。
对于系统来说，则希望进入系统的作业的平均周转时间尽可能的小，是的CPU的利用率尽量高。
于是，每个计算机系统都必须选择适当的作业调度算法，既考虑用户的要求又要有利于系统效率的提高。
当选中一个作业后，首先要建立此作业的用户进程，同时为其分配系统资源，接着就可以投入运行。
当一个作业执行结束进入完成状态时，负责收回资源，撤销其作业控制块。
操作系统课程设计---作业调度模拟
操作系统课程设计---作业调度模拟《操作系统课程设计作业调度模拟》在计算机科学领域，操作系统是管理计算机硬件与软件资源的核心系统，而作业调度则是操作系统中的一个关键环节。
作业调度的主要任务是根据一定的策略，将系统中的作业合理地分配到处理机上执行，以提高系统的资源利用率和作业的执行效率。
本次课程设计的目标就是模拟实现一个简单的作业调度系统，通过对作业调度算法的设计和实现，深入理解操作系统中作业调度的原理和机制。
首先，让我们来了解一下作业调度的基本概念和常见的调度算法。
作业调度的主要目标是在多个作业之间合理地分配处理机资源，以满足不同作业的执行需求。
常见的作业调度算法包括先来先服务（FCFS）、短作业优先（SJF）、优先级调度、高响应比优先调度等。
先来先服务算法是最简单的调度算法，它按照作业到达系统的先后顺序进行调度。
这种算法的优点是实现简单、公平，但缺点是对于长作业可能会导致短作业长时间等待，从而影响系统的整体性能。
短作业优先算法则优先调度执行时间短的作业。
这种算法能够有效地减少作业的平均等待时间，提高系统的吞吐量，但可能会导致长作业长时间得不到调度，出现“饥饿”现象。
优先级调度算法为每个作业赋予一个优先级，系统根据优先级的高低来进行调度。
优先级可以根据作业的紧急程度、重要性等因素来确定。
这种算法能够灵活地满足不同作业的需求，但需要合理地设置优先级，否则可能会导致调度的不公平。
高响应比优先调度算法则综合考虑了作业的等待时间和执行时间，通过计算响应比来决定调度顺序。
响应比的计算公式为：响应比＝（等待时间＋执行时间）／执行时间。
这种算法在一定程度上避免了短作业优先算法中长作业的“饥饿”问题，同时也能保证短作业的优先调度。
在本次课程设计中，我们选择使用 C 或 C+＋语言来实现作业调度模拟系统。
系统的主要功能包括作业的创建、作业队列的管理、调度算法的实现以及作业执行情况的输出。
为了实现作业的创建，我们定义了一个作业结构体，其中包含作业的编号、到达时间、执行时间、优先级等信息。
操作系统课程设计-进程调度算法模拟
操作系统课程设计----进程调度算法模拟一、实验内容：模拟五种进程调度算法并计算各参数值二、实验原理：（1）先来先服务调度：最先到达的进程先进行调度（2）短作业优先调度：从已到达的进程中选出最短的进程优先调度（3）时间片轮转调度：每个进程依次的按时间片轮流的方式执行（4）静态优先权调度：赋予优先权，在已到达的进程中选出优先权最高的优先调度（5）高响应比优先调度：优先权随等待时间而增加，从而使等待时间较长且服务时间较短的进程优先调度响应比=1+等待时间/服务时间三、实验设计说明：本程序采用C++ Builder 5编程和设计界面考虑到调度算法较多，采用了多页面的界面（如下图），加入的进程限制五个，在文本框中模拟到达一进程后，输入到达时间和服务时间，点击“加入新进程”即可，输入完成之后，点击运行即可得到表中各值。
想从新输入可点击“清除”按钮。
关闭时直接点击“×”即可。
该程序还不是很完善，有一些小问题，尚待解决，还得向老师请教。
四、实验结果：（只打印两个结果示范）运行后操作面板初始化如下图：短作业优先结果如图：时间片轮转结果如图：（书上的例题）五、实验源程序：Unit1.h文件//---------------------------------------------------------------------------#ifndef Unit1H#define Unit1H//---------------------------------------------------------------------------#include <Classes.hpp>#include <Controls.hpp>#include <StdCtrls.hpp>#include <Forms.hpp>#include <ComCtrls.hpp>#include <Grids.hpp>#include <ExtCtrls.hpp>//--------------------------------------------------------------------------- class TForm1 : public TForm{__published: // IDE-managed ComponentsTPageControl *PageControl1; TTabSheet *TabSheet1; TTabSheet *TabSheet2; TTabSheet *TabSheet3; TTabSheet *TabSheet4; TabSheet *TabSheet5; TStringGrid *sgr;TButton *Button1;TButton *Button2;TButton *Button3; TStringGrid *sgr1;TButton *Button4;TButton *Button5;TButton *Button6; TStringGrid *sgr2;TButton *Button7;TButton *Button8;TButton *Button9; TStringGrid *sgr3;TButton *Button10; TButton *Button11; TButton *Button12; TStringGrid *sgr4;TButton *Button13; TButton *Button14; TButton *Button15;TLabel *Label1;TEdit *Edit1;TLabel *Label2;TEdit *Edit2;TEdit *Edit3;TEdit *Edit4;TLabel *Label3;TLabel *Label4;TEdit *Edit5;TLabel *Label5;TLabel *Label6;TEdit *Edit6; TLabel *Label7;TEdit *Edit7;TLabel *Label8;TLabel *Label9;TLabel *Label10;TEdit *Edit8;TEdit *Edit9;TEdit *Edit10;TLabel *Label11;TLabel *Label12;TEdit *Edit11;TEdit *Edit12;void __fastcall FormCreate(TObject *Sender);void __fastcall Button3Click(TObject *Sender);void __fastcall Button1Click(TObject *Sender);void __fastcall Button2Click(TObject *Sender);void __fastcall Button6Click(TObject *Sender);void __fastcall Button5Click(TObject *Sender);void __fastcall Button4Click(TObject *Sender);void __fastcall Button9Click(TObject *Sender);void __fastcall Button7Click(TObject *Sender);void __fastcall Button8Click(TObject *Sender);void __fastcall Button12Click(TObject *Sender); void __fastcall Button10Click(TObject *Sender); void __fastcall Button11Click(TObject *Sender);void __fastcall Button15Click(TObject *Sender); void __fastcall Button13Click(TObject *Sender); void __fastcall Button14Click(TObject *Sender);private: // User declarationspublic: // User declarations__fastcall TForm1(TComponent* Owner);};//---------------------------------------------------------------------------extern PACKAGE TForm1 *Form1;//---------------------------------------------------------------------------#endif******************************************************************************* Unit1.cpp文件//--------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "Unit1.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;float super[6]; //优先权float come[6]; //到达时间float serve[6]; //服务时间float begin[6]; //开始执行时间float end[6]; //完成时间float all[6]; //周转时间float dall[6]; //带权周转时间float max(float,float,float);//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) //初始化表格: TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){sgr->Cells[0][0]="进程名";sgr1->Cells[0][0]="进程名";sgr2->Cells[0][0]="进程名";sgr3->Cells[0][0]="进程名";sgr4->Cells[0][0]="进程名";sgr3->Cells[0][1]="优先权";sgr->Cells[0][1]="到达时间";sgr1->Cells[0][1]="到达时间";sgr2->Cells[0][1]="到达时间";sgr3->Cells[0][2]="到达时间";sgr4->Cells[0][1]="到达时间";sgr->Cells[0][2]="服务时间";sgr1->Cells[0][2]="服务时间";sgr2->Cells[0][2]="服务时间";sgr3->Cells[0][3]="服务时间";sgr4->Cells[0][2]="服务时间";sgr->Cells[0][3]="开始执行时间";sgr1->Cells[0][3]="开始执行时间";sgr3->Cells[0][4]="开始执行时间";sgr4->Cells[0][3]="开始执行时间";sgr4->Cells[0][4]="等待时间";sgr4->Cells[0][5]="响应比";sgr->Cells[0][4]="完成时间";sgr1->Cells[0][4]="完成时间";sgr2->Cells[0][3]="完成时间";sgr3->Cells[0][5]="完成时间";sgr4->Cells[0][6]="完成时间";sgr->Cells[0][5]="周转时间";sgr1->Cells[0][5]="周转时间";sgr2->Cells[0][4]="周转时间";sgr3->Cells[0][6]="周转时间";sgr4->Cells[0][7]="周转时间";sgr->Cells[0][6]="带权周转时间";sgr1->Cells[0][6]="带权周转时间";sgr2->Cells[0][5]="带权周转时间";sgr3->Cells[0][7]="带权周转时间";sgr4->Cells[0][8]="带权周转时间";sgr->Cells[0][7]="显示调度结果";sgr1->Cells[0][7]="显示调度结果";sgr3->Cells[0][8]="显示调度结果";sgr4->Cells[0][9]="显示调度结果";}//---------------------------------------------------------------------------//先来先服务调度算法void __fastcall TForm1::Button3Click(TObject *Sender) //输入初值，5个{static int i=1;sgr->Cells[i][0]=i; //进程编号sgr->Cells[i][1]=Edit1->Text; //输入到达时间come[i]=StrToFloat(Edit1->Text); //赋到达时间给表格sgr->Cells[i][2]=Edit2->Text; //输入服务时间serve[i]=StrToFloat(Edit2->Text); // 赋服务时间给表格i++;if(i>5) i=1;}//---------------------------------------------------------------------------float max(float x,float y,float m) //定义函数{return (x+y)>m?(x+y):m;}//---------------------------------------------------------------------------//““运行”按键函数void __fastcall TForm1::Button1Click(TObject *Sender){int i=1;begin[1]=come[1];sgr->Cells[1][3]=begin[1]; //初始值for(i=2;i<=5;i++){begin[i]=max(serve[i-1],begin[i-1],come[i]); //调用函数sgr->Cells[i][3]=begin[i];} //开始执行时间for(i=1;i<=5;i++) //计算各个值{end[i]=begin[i]+serve[i];sgr->Cells[i][4]=end[i];all[i]=end[i]-come[i];sgr->Cells[i][5]=all[i];dall[i]=all[i]/serve[i];sgr->Cells[i][6]=dall[i];sgr->Cells[i][7]=i;}}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button2Click(TObject *Sender){ int i=0,j=0;for(i=0;i<=7;i++)for(j=1;j<=5;j++){sgr->Cells[j][i]="";}}//---------------------------------------------------------------------------//短作业优先调度函数//“加入新进程”输入初值void __fastcall TForm1::Button6Click(TObject *Sender){static int i=1;sgr1->Cells[i][0]=i; //进程编号sgr1->Cells[i][1]=Edit3->Text;come[i]=StrToFloat(Edit3->Text);sgr1->Cells[i][2]=Edit4->Text;serve[i]=StrToFloat(Edit4->Text);i++;if(i>5) i=1;}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button5Click(TObject *Sender){ int i=0,j=0;for(i=0;i<=7;i++)for(j=1;j<=5;j++){sgr1->Cells[j][i]="";}}//---------------------------------------------------------------------------//“运行”按钮函数void __fastcall TForm1::Button4Click(TObject *Sender){int i,j,k,run=1,index=1,flag[6]={1,1,1,1,1,1},t[4]; //flag用于设置访问值“1”为未访问sgr1->Cells[1][7]="1";begin[1]=come[1];sgr1->Cells[1][3]=FloatToStr(begin[1]);end[1]=begin[1]+serve[1];sgr1->Cells[1][4]=FloatToStr(end[1]);sgr1->Cells[1][5]=FloatToStr(end[1]-come[1]);sgr1->Cells[1][6]=FloatToStr((end[1]-come[1])/serve[1]); //初始化for(j=1;j<=4;j++){index++; //index自动指向下一个进程if (index>5) //index值的复位{for(k=2;k<=5;k++)if (flag[k]==1){index=k; //index指向第一个未执行的进程break;}}for(i=2;i<=5;i++)//满足三个条件的进程才可调度，1、已到达2、未调度过3、服务时间最小{ if ((come[i]<=end[run])&&(serve[index]>serve[i])&&(flag[i]==1)){index=i;}else if (come[i]>end[run]) //如果一进程完成未有进程到达，则下一个进程到来就直接调度break;}flag[index]=0;//处理index，index为当前运行的进程编号，run为上一个进程的编号begin[index]=max(serve[run],begin[run],come[index]); //开始执行时间sgr1->Cells[index][3]=FloatToStr(begin[index]);run=index;end[index]=begin[index]+serve[index]; //计算完成时间sgr1->Cells[index][4]=FloatToStr(end[index]);all[index]=end[index]-come[index]; //计算周转时间sgr1->Cells[index][5]=FloatToStr(all[index]);sgr1->Cells[index][6]=FloatToStr(all[index]/serve[index]); //赋带权周转时间t[j]=index; // t[j]为调度序列}for(i=1;i<=4;i++)sgr1->Cells[i+1][7]=FloatToStr(t[i]); //显示调度结果}//---------------------------------------------------------------------------//时间片轮转调度算法void __fastcall TForm1::Button9Click(TObject *Sender){static int i=1;sgr2->Cells[i][0]=i; //进程编号sgr2->Cells[i][1]=Edit5->Text;come[i]=StrToFloat(Edit5->Text);sgr2->Cells[i][2]=Edit6->Text;serve[i]=StrToFloat(Edit6->Text);i++;if(i>5) i=1;}//---------------------------------------------------------------------------//“运行”按钮函数void __fastcall TForm1::Button7Click(TObject *Sender){int i=1,j=1,flag[6]={1,1,1,1,1,1};float t=0,q,a[6]; // q为时间片大小q=StrToFloat(Edit7->Text); //赋值给qfor(i=1;i<=5;i++)a[i]=serve[i];for(j=1;j<=100;j++) //设总时间片不超过100{for(i=1;i<=5;i++){if(flag[i]==1){ serve[i]-=q; //计算服务时间if(serve[i]>0){t+=q; //t为当前执行的总时间}else if(serve[i]<=0){t+=(q+serve[i]); //t为当前执行的总时间end[i]=t; //进程调度完毕送完成时间flag[i]=0; //一旦进程被调度后置flag值为0}}}}for(i=1;i<=5;i++) //显示结果{sgr2->Cells[i][3]=FloatToStr(end[i]);all[i]=end[i]-come[i];sgr2->Cells[i][4]=FloatToStr(all[i]);sgr2->Cells[i][5]=FloatToStr(all[i]/a[i]);}}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button8Click(TObject *Sender){int i=0,j=0;for(i=0;i<=6;i++)for(j=1;j<=5;j++){sgr2->Cells[j][i]="";}}//---------------------------------------------------------------------------//优先权调度算法（原理类似短作业优先）//“加入新进程”输入初值void __fastcall TForm1::Button12Click(TObject *Sender){static int i=1;sgr3->Cells[i][0]=i; //进程编号sgr3->Cells[i][1]=Edit8->Text;super[i]=StrToFloat(Edit8->Text);sgr3->Cells[i][2]=Edit9->Text;come[i]=StrToFloat(Edit9->Text);sgr3->Cells[i][3]=Edit10->Text;serve[i]=StrToFloat(Edit10->Text);i++;if(i>5) i=1;}//---------------------------------------------------------------------------//“运行”按钮函数void __fastcall TForm1::Button10Click(TObject *Sender){int i,j,k,run=1,index=1,flag[6]={1,1,1,1,1,1},t[4]; //run为上一个调度的进程号sgr3->Cells[1][8]="1";begin[1]=come[1];sgr3->Cells[1][4]=FloatToStr(begin[1]);end[1]=begin[1]+serve[1];sgr3->Cells[1][5]=FloatToStr(end[1]);sgr3->Cells[1][6]=FloatToStr(end[1]-come[1]);sgr3->Cells[1][7]=FloatToStr((end[1]-come[1])/serve[1]);//初始化for(j=1;j<=4;j++){index++;while(flag[index]==0){index++;} //index指向下一个待运行的进程if (index>5) //index值的复位{for(k=2;k<=5;k++)if (flag[k]==1){index=k;break;}}for(i=2;i<=5;i++){ if ((come[i]<=end[run])&&(super[index]>super[i])&&(flag[i]==1)){index=i; //满足条件的进程号送给index}else if (come[i]>end[run])break;}flag[index]=0;//处理indexbegin[index]=max(serve[run],begin[run],come[index]);sgr3->Cells[index][4]=FloatToStr(begin[index]);run=index;end[index]=begin[index]+serve[index];sgr3->Cells[index][5]=FloatToStr(end[index]);all[index]=end[index]-come[index];sgr3->Cells[index][7]=FloatToStr(all[index]/serve[index]);t[j]=index;}for(i=1;i<=4;i++)sgr3->Cells[i+1][8]=FloatToStr(t[i]);}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button11Click(TObject *Sender){int i=0,j=0;for(i=0;i<=9;i++)for(j=1;j<=5;j++)sgr3->Cells[j][i]="";}//---------------------------------------------------------------------------//高响应比优先调度算法（类似优先权调度算法，响应比为动态的）//“清除”按键函数void __fastcall TForm1::Button15Click(TObject *Sender){static int i=1;sgr4->Cells[i][0]=i; //进程编号sgr4->Cells[i][1]=Edit11->Text;come[i]=StrToFloat(Edit11->Text);sgr4->Cells[i][2]=Edit12->Text;serve[i]=StrToFloat(Edit12->Text);i++;if(i>5) i=1;}//---------------------------------------------------------------------------//“运行”按钮函数void __fastcall TForm1::Button13Click(TObject *Sender){int i,j,k,run=1,index=1,flag[6]={1,1,1,1,1,1},t[4];float xy[6]; //xy[]为响应比数组sgr4->Cells[1][9]="1";begin[1]=come[1];sgr4->Cells[1][3]=FloatToStr(begin[1]);sgr4->Cells[1][4]="0";xy[1]=1+0;sgr4->Cells[1][5]=FloatToStr(xy[1]);end[1]=begin[1]+serve[1];sgr4->Cells[1][6]=FloatToStr(end[1]);sgr4->Cells[1][8]=FloatToStr((end[1]-come[1])/serve[1]); //初始化for(j=1;j<=4;j++){index++;if (index>5){for(k=2;k<=5;k++)if (flag[k]==1){index=k;break;}}for(i=2;i<=5;i++){ if ((come[i]<end[run])&&((end[run]-come[index])/serve[index]<(end[run]-come[index])/serve[i]) &&(flag[i]==1)) //动态计算响应比并比较{index=i;}else if (come[i]>end[run])break;}flag[index]=0;//处理indexbegin[index]=max(serve[run],begin[run],come[index]);sgr4->Cells[index][3]=FloatToStr(begin[index]);sgr4->Cells[index][4]=FloatToStr(end[run]-come[index]);xy[index]=1+(end[run]-come[index])/serve[index];sgr4->Cells[index][5]=FloatToStr(xy[index]);run=index;end[index]=begin[index]+serve[index];sgr4->Cells[index][6]=FloatToStr(end[index]);all[index]=end[index]-come[index];sgr4->Cells[index][7]=FloatToStr(all[index]);sgr4->Cells[index][8]=FloatToStr(all[index]/serve[index]);t[j]=index;}for(i=1;i<=4;i++)sgr4->Cells[i+1][9]=FloatToStr(t[i]);}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button14Click(TObject *Sender){int i=0,j=0;for(i=0;i<=9;i++)for(j=1;j<=5;j++)sgr4->Cells[j][i]="";}//---------------------------------------------------------------------------六、实验总结：此次实验花了一周多的时间完成了程序的编写和界面设计，这其中也走了不少弯路。
操作系统课程设计——作业模拟调度实验
作业模拟调度实验1 课程设计的目的通过该题目的设计过程，可以初步掌握作业调度的原理、软件开发方法并提高解决实际问题的能力。
了解UNIX的命令及使用格式，熟悉UNIX/LINUX的常用基本命令，练习并掌握UNIX提供的vi编辑器来编译C程序，学会利用gcc、gdb编译、调试C程序。
2 课程设计的开发语言程序设计所选用的程序设计语言为C语言。
3 功能描述先来先服务算法比较有利于长作业，而不利于短作业。
（1）短作业（SJF）的调度算法可以照顾到实际上在所有作业中占很大比例的短作业，使它能比长作业优先执行。
SPF优先调度算法：是从就绪队列中选出一估计运行时间最短的进程，将处理机分配给它，使它立即执行到完成，或发生某事件而被阻塞放弃处理机时，再重新调度。
为了和FCFS调度算法进行比较，我们利用FCFS算法中所使用的实例并改用SJ（P）F算法重新调度，再进行性能分析。
采用SJF算法后，不论是平均周转时间还是平均带权周转时间都有较明显的改善，尤其是对短作业D，其周转时间由FCFS算法的11降为SJF算法中的3；而平均带权周转时间是从5.5降到1.5。
这说明SJF调度算法能有效地降低作业的平均等待时间和提高系统的吐量。
短作业优先调度算法对比先来先服务，不论是平均周转时间还是平均带权周转时间，都有较明显的改善，尤其是对短作业。
该算法对长作业不利，而且未考虑作业的紧迫程度，因而不能保证紧迫性作业会被及时处理。
如作业C的周转时间由10增至16，带权周转时间由2增至3.1。
更严重的是，如果有一长作业（进程）进入系统的后备队列（就绪队列），由于调度程序总是优先调度那些（即使是后进来的）短作业（进程），将致使长作业（进程）得不到调度。
（2）该算法完全未考虑作业的紧迫程度，因而不能保证紧迫性作业（进程），会得到及时处理；（3）由于作业（进程）的长短只是根据用户所提供的估计执行时间而定，而用户又可能会有意或无意地缩短其作业的估计执行时间，致使该算法不一定能真正做到短作业优先调度。
操作系统进程调度模拟程序实验报告
目录1、课程设计目的 (3)2、课程设计要求 (3)3、相关知识 (3)4、需求分析 (4)5、概要设计 (5)6、详细设计 (6)7、测试，修改及运行结果 (13)8、参考文献 (15)9、结束语 (15)10、附件 (15)1、课程设计的目的理解操作系统进程管理中进行进程调度的过程和编程方法，掌握先来先服务调度算法和最高优先数优先的调度算法，创建进程控制块PCB。
理解进程的状态及变化，动态显示每个进程的当前状态及进程的调度情况2、课程设计要求编写一个进程调度程序，允许多个进程共行的进程调度程序1）.进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
2）.每个进程有一个进程控制块（ PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等.3）.进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为输入进程的时间。
4）．进程的运行时间以时间片为单位进行计算。
5）.每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
.6）.就绪进程获得 CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
7）.如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
8）.每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止3、相关知识进程：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动进程的状态：运行状态：进程正在处理器上运行就绪状态：一个进程获得了除处理器外的一切所需资源，一旦得到处理器即可运行等待状态：一个进程正在等待某一事件发生而暂时停止运行先进先出调度算法：其基本原则是按照作业到达系统或进程进入就绪对列的先后次序来选择。
操作系统实验--作业调度模拟
一、实验目的和内容1、实验目的用高级语言编写和调试一个或多个作业调度的模拟程序，以加深对作业调度算法的理解。
2、实验内容编写并调试一个单道处理系统的作业等待模拟程序。
作业等待算法：分别采用先来先服务（FCFS），最短作业优先（SJF）、响应比高者优先（HRN）的调度算法。
对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间，以比较各种算法的优缺点。
二、实验方案1、先来先服务算法原理：每次调度是从就绪队列中，选择一个最先进入就绪队列的进程，把处理器分配给该进程，使之得到执行。
该进程一旦占有了处理器，它就一直运行下去，直到该进程完成或因发生事件而阻塞，才退出处理器。
特点：利于长进程，而不利于短进程。
2、短作业优先服务算法原理：它是从就绪队列中选择一个估计运行时间最短的进程，将处理器分配给该进程，使之占有处理器并执行，直到该进程完成或因发生事件而阻塞，然后退出处理器，再重新调度。
3、最高响应比优先算法原理：它是从就绪队列中选择一个响应比最高的进程，让其获得处理器执行，直到该进程完成或因等待事件而退出处理器为止。
特点：既照顾了短进程，又考虑了进程到达的先后次序，也不会使长进程长期得不到服务，因此是一个比较全面考虑的算法，但每次进行调度时，都需要对各个进程计算响应比。
所以系统开销很大，比较复杂。
4、源代码#include<iostream.h>#include<stdlib.h>#include<stdio.h>typedef struct JCB //定义作业控制块JCB结构体{int ID; //作业标识数IDfloat requesttime; //作业运行所需要时间requesttimeint runtime; //作业实际运行时间runtimeint arrivetime; //作业到达时间arrivetimeint starttime; //作业开始时间starttimeint finishtime; //作业完成时间finishtimefloat zhuantime; //作业周转时间zhuantime}JCB;#define N 100 //宏定义JCB jcb[N]; //定义作业块数组int jcbnum; //定义作业块个数void init(); //初始化函数void FCFS(); //先来先服务算法void SJF(); //短作业优先算法void HRN(); //高响应比算法void init() //初始化作业调度块{int j=0;int req;while(j<=0||j>2000) //实现作业的输入{cout<<"请输入作业个数:(1--2000)";cin>>j;}jcbnum=j;for(j=0;j<jcbnum;j++) //实现作业的循环执行{cout<<"请输入第"<<j+1<<"个作业的完成所需时间，默认达到时间为"<<j<<endl;cin>>req;jcb[j].ID=j+1;jcb[j].requesttime=req;jcb[j].arrivetime=j;jcb[j].starttime=0;jcb[j].finishtime=0;jcb[j].zhuantime=0;}}void FCFS() //先到先服务算法的实现{int i;float a,b;b=a=0;cout<<"你选择用先到先服务算法进行作业调度，结果如下:"<<endl;cout<<"作业到达时间运行时间开始时间完成时间周转时间带权周转时间"<<endl;for(i=0;i<jcbnum;i++){int runtime=0;jcb[i].finishtime=jcb[i].starttime+jcb[i].requesttime;jcb[i].zhuantime=jcb[i].finishtime-jcb[i].arrivetime;cout<<" "<<jcb[i].ID<<"\t "<<jcb[i].arrivetime<<"\t "<<jcb[i].requesttime<<"\t "<<jcb[i].starttime<<"\t "<<jcb[i].finishtime<<"\t "<<jcb[i].zhuantime<<"\t "; /*输出作业的作业到达时间运行时间开始时间完成时间周转时间*/cout<<jcb[i].zhuantime/jcb[i].requesttime<<endl;jcb[i+1].starttime=jcb[i].finishtime;a+=jcb[i].zhuantime;b+=jcb[i].zhuantime/jcb[i].requesttime;}cout<<"平均周转时间："<<a/jcbnum<<endl;cout<<"平均带权周转时间："<<b/jcbnum<<endl;}void SJF()//短作业优先算法{int i,j,r,c,fin=0; float a,b;a=b=0;c=jcbnum;cout<<"你选择用短作业优先算法进行作业调度，结果如下"<<endl;cout<<"作业到达时间运行时间开始时间完成时间周转时间带权周转时间"<<endl;while(jcbnum>0){r=0;for(i=0;i<jcbnum;i++)if(jcb[r].requesttime>jcb[i].requesttime)r=i;jcb[r].starttime=fin;jcb[r].finishtime=fin+jcb[r].requesttime;jcb[r].zhuantime=jcb[r].finishtime-jcb[r].arrivetime;a+=jcb[r].zhuantime;b+=jcb[r].zhuantime/jcb[r].requesttime;cout<<" "<<jcb[r].ID<<"\t "<<jcb[r].arrivetime<<"\t "<<jcb[r].requesttime<<"\t "<<jcb[r].starttime<<"\t "<<jcb[r].finishtime<<"\t "<<jcb[r].zhuantime<<"\t ";cout<<jcb[r].zhuantime/jcb[r].requesttime<<endl;fin+=jcb[r].requesttime;for(j=r;j<jcbnum-1;j++){jcb[j].ID=jcb[j+1].ID;jcb[j].requesttime=jcb[j+1].requesttime;jcb[j].arrivetime=jcb[j+1].arrivetime;}jcbnum--;}cout<<"平均周转时间："<<a/c<<endl;cout<<"平均带权周转时间："<<b/c<<endl;cout<<endl;}void HRN()//高响应比算法{int i,j,r,c;float a,b;a=b=0;c=jcbnum;int waittime=0; //进程等待处理机所用时间cout<<"你选择高响应比优先算法进行作业调度，结果如下:"<<endl;cout<<"作业到达时间运行时间开始时间完成时间周转时间带权周转时间"<<endl;while(jcbnum>0){r=0;for(i=0;i<jcbnum;i++) //选择响应比最高的进程if((waittime+0.0)/jcb[r].requesttime>((waittime+0.0)/jcb[i].requesttime)) r=i;jcb[r].starttime=waittime;jcb[r].finishtime=waittime+jcb[r].requesttime;jcb[r].zhuantime=jcb[r].finishtime-jcb[r].arrivetime;a+=jcb[r].zhuantime;b+=jcb[r].zhuantime/jcb[r].requesttime;cout<<" "<<jcb[r].ID<<"\t "<<jcb[r].arrivetime<<"\t "<<jcb[r].requesttime<<"\t "<<jcb[r].starttime<<"\t "<<jcb[r].finishtime<<"\t "<<jcb[r].zhuantime<<"\t ";cout<<jcb[r].zhuantime/jcb[r].requesttime<<endl;waittime+=jcb[r].requesttime;for(j=r;j<jcbnum-1;j++){jcb[j].ID=jcb[j+1].ID;jcb[j].requesttime=jcb[j+1].requesttime;jcb[j].arrivetime=jcb[j+1].arrivetime;}jcbnum--;}cout<<endl;}//主函数void main(){ bool flog=1;int i=0;char ch;cout<<"********************************"<<endl;cout<<" | 1:先来先服务 |"<<endl;cout<<" | 2:短作业优先 |"<<endl;cout<<" | 3:最高响应比优先 |"<<endl;cout<<"********************************"<<endl;while(flog){init();a1: cout<<"请选择你要做的选项(1--3):";cin>>i;if(i>=0&&i<=3){switch(i){case 1:FCFS();break; //选择"1"的时候调用的是FCFS算法case 2:SJF();break; //选择"2"的时候调用的是SJF算法 case 3:HRN();break; //选择"3"的时候调用的是HRN算法}cout<<endl; }else{ cout<<"输入错误，请重新输入！"<<endl; goto a1;}cout<<"是否想要继续(N/Y)?:"; //是否继续执行cin>>ch;if(ch=='y'||ch=='Y') flog=1;else flog=0;}}三、实验数据、结果分析运行结果分别输入3个作业，选择不同的算法进行调度。
操作系统综合实验报告--作业调度算法模拟
{
if(p［j]。subtime<=p[i］。ftime)
k++；
｝
doublemaxrratio=(p[i].ftime-p[i+1］。subtime）/(1。0*p［i+1]。runtime);
int ps=i+1；
for（int m=i+1；m<i+k；m++)
p[i].subtime=(p[i］.subtime）/100*60+p[i］。subtime％100;
cout<〈”运行时间："；
cin〉>p[i］。runtime；
p［i]。runtime=(p［i］。runtime）/100*60+p［i].runtime％100；
cout〈〈”\n”;
}
}
void output(job＊p,int n）
if(i==0)
p[i］.ftime=p［i]。subtime+p[i].runtime;
else
p[i］.ftime=p[i］.runtime+p[i—1］。ftime;
for(int j=i+1；j〈n;j++）
｛
if（p[j］。subtime<=p[i].ftime)
k++;
}
double minstime=p[i+1］。runtime；
p[i］。ftime=p［i—1]。ftime+p[i］。runtime;
/＊这里要特别小心，刚开始没考虑到下一个的开始时间可能大于上一个
操作系统课程设计进程调度模拟设计
课程设计课程名字系统软件开发实训A题目进程调度模拟设计一一先来先服务、优先级法学院计算机科学与技术学院专业计算机科学与技术专业班级姓名指导教师李玉强2014 年01月13 日天天天天天天课程设计任务书学生姓名： _________ 专业班级： ______________ 指导教师：李玉强工作单位： 计算机科学与技术学院题目：进程调度模拟设计一一先来先服务、优先级法初始条件:1 •预备内容：阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有 深入的理解。
2 •实践准备：掌握一种计算机高级语言的使用。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1 •模拟进程调度，能够处理以下的情形：⑴ 能够选择不同的调度算法（要求中给出的调度算法）；⑵ 能够输入进程的基本信息， 如进程名、优先级、到达时间和运行时间等; ⑶根据选择的调度算法显示进程调度队列；⑷ 根据选择的调度算法计算平均周转时间和平均带权周转时间。
2 •设计报告内容应说明： ⑴课程设计目的与功能；⑵需求分析，数据结构或模块说明 （功能与框图）； ⑶ 源程序的主要部分；⑷ 测试用例，运行结果与运行情况分析； ⑸自我评价与总结。
时间安排：设计安排3周：查阅、分析资料 1 系统软件的分析与建模 4系统软件的设计 5 系统软件的实现 3 撰写文档 1课程设计验收答辩1 设计验收安排：设计周的第三周的指定时间到实验室进行上机验收 设计报告书收取时间：课程设计验收答辩完结时。
（注意事项：严禁抄袭，一旦发现，抄与被抄的一律按0分记）指导教师签名：2013 年12月10日系主任(或责任教师)签名：2013 年12月10日课程设计报告书1•需求分析1.1设计目的(1) 阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解。
(2) 掌握一种计算机高级语言的使用。
要求完成的主要任务：(包括课程设计工作量及其技术要求，以及说明书撰写等具体要求) 1.2程序流程图1.3设计要求(1) 能够选择不同的调度算法(要求中给出的调度算法)；(2) 能够输入进程的基本信息，如进程名、优先级、到达时间和运行时间等;(3) 根据选择的调度算法显示进程调度队列；(4) 根据选择的调度算法计算平均周转时间和平均带权周转时间。
作业调度算法模拟系统课程设计报告
操作系统课程设计（学年设计、学年论文）任务书操作系统课程设计说明书学院名称：计算机与信息工程班级名称： 2011级网络工程2班学生姓名：童玉龙周速吴明诏汪泽王边学号： 2011211299 2011211346 2011211318 2011302 2011211303 题目：作业调度算法模拟系统指导教师姓名：张燕玲起止日期： 2013年6月3日~2013年6月30日第一部分：正文部分一、选题背景操作系统课程设计是集中实践性环节之一，是学习完《操作系统》课程后进行的一次全面的综合练习。
本次课程设计级要求学生达到熟练掌握操作系统的基本理论知识；掌握不同的调度算法；能够利用所学的基本编程知识，实现课程章节中涉及到的一些基本算法，从而加深理论知识的理解，树立掌握操作系统中各种作业调度算法。
二、设计思路作业调度的实质是一种资源分配，调度算法是指根据系统的资源分配策略所规定的额资源分配算法。
为了理解和掌握先来先服务（FCFS），最短作业优先（SJF）、响应比高者优先（HRN）三种算法，可以做如下工作；1．设置作业形式，应包含如下信息：作业号、作业到达时间、作业要求服务时间、等待时间、开始运行时间、结束运行时间、周转时间、带权周转时间、优先权和是否已经完成；2. 设置一个作业数量num；3．分别采用先来先服务（FCFS），最短作业优先（SJF）、响应比高者优先（HRN）的调度算法对队列中的作业进行调度；4．先来先服务（FCFS）对先来的作业优先处理；5．最短作业优先（SJF）对已就绪作业进行短作业优先服务；6．响应比=（等待时间+需要服务时间）/需要服务时间，响应比高者优先（HRN）是对已就绪作业进行响应比高者优先服务，以免一些程序长时间不能被执行；7．对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间，以比较各种算法优劣。
三、过程论述3.1模拟实现作业调度算法中三种算法的简介该三种算法包括：FCFS（先来先服务算法）、SJF（短作业优先算法）、HRN（最高响应比优先算法）。
操作系统课程设计(作业调度)任务书
一、课程设计的原始资料及依据查阅有关计算机操作系统的教材、实验指导书等资料，进一步熟悉操作系统的基本原理，算法的设计思想。
作业调度是批处理操作系统中的重要内容。
本设计要求用高级语言编写和调试一个简单的作业调度程序。
通过本设计可以加深理解有关作业控制块、作业队列的概念，并体会和了解先来先服务、短作业优先和响应比高者优先作业调度算法的具体实施办法。
加深理解有关作业控制块、作业队列的概念和状态转换。
二、课程设计主要内容及要求1．认真阅读资料，掌握作业调度的原理和相关算法的思想。
2．要求在设计的过程中，建立清晰的层次结构。
3．画出主要的功能结构图和主要算法的流程图。
4．设计作业控制块JCB表结构，分别适用于先来先服务、短作业优先和响应比高者优先调度算法。
JCB结构通常包括以下信息：作业名，作业到达系统的时间，作业要求服务时间，作业的完成时间等。
根据调度算法的不同，JCB结构的内容可以作适当的增删。
5．建立作业并送入后备队列。
对两种不同算法编制入链子程序。
6．分别显示三种不同算法下，后备队列中所有的作业排列情况。
7．编制作业调度算法：先来先服务、短作业优先和响应比高者优先调度算法。
8．显示根据不同调度算法形成的作业调度顺序。
9．运行程序，检查结果是否和理论值一致。
10．环境可以使用Windows，Turbo C环境或Linux。
三、对课程设计说明书撰写内容、格式、字数的要求1．课程设计说明书是体现和总结课程设计成果的载体，主要内容包括：设计题目、设计目的、设备器材、设计原理及内容、设计步骤、遇到的问题及解决方法、设计总结、参考文献等。
一般不应少于3000字。
2．在适当位置配合相应的实验原理图、功能模块图、算法流程图等图表进行说明。
应做到文理通顺，内容正确完整，书写工整，装订整齐。
3．设计总结部分主要写本人完成工作简介以及自己的设计体会，包括通过课程设计学到了什么，哪里遇到了困难，解决的办法以及今后的目标。
操作系统课程设计——进程调度模拟算法(5种)
福建农林大学计算机与信息学院课程设计报告课程名称：操作系统实习题目：进程调度算法模拟姓名：***系：计算机专业：计算机科学与技术年级：2011级学号：**指导教师：***职称：***2014年1月16日福建农林大学计算机与信息学院信息工程类课程设计报告结果评定目录1.进程调度算法模拟课程设计的目的 (1)2.进程调度算法模拟课程设计的要求 (1)3.进程调度算法模拟课程设计报告内容 (1)3．1前言 (1)3．2进程调度算法模拟设计的环境 (1)3．3系统流程图及各模块 (2)4．总结 (18)参考文献 (19)参考网站 (19)进程调度算法模拟1.进程调度算法模拟课程设计的目的和意义2013-2014学年，在学习了《操作系统》这门课后，对当中的进程调度算法产生了浓厚的兴趣。
各种调度算法，理论上比较好理解。
为了加深印象，我决定把各种调度算法用C语言写出来。
于是便产生这份从头到尾都让我绞尽脑汁的课程设计。
做这份课程设计，对从事系统开发的人员来说，是必要的，可以在一定程度上为自己以后的发展铺路。
虽然用处不是特别明显，但对加深系统调用算法的理解无疑用处是巨大的。
2.进程调度算法模拟课程设计的要求1.用C语言写出至少两种进程调度算法。
2.画出大概流程图。
3.对算法过程出现的bug进行调试。
4.展示最后的算法结果3.1前言：目前比较常见的几种进程调度算法有：1.先到先服务(FCFS)2.短进程优先（非抢占和抢占）算法(SPF)3.高响应比优先算法4.时间片轮转算法我选出其中三种即先到先服务，短进程优先（2种）和时间片轮转算法进行C语言描述以加深对这三种算法的理解。
3.2进程调度算法模拟设计的环境VC++6.0及CodeBlocks，32位计算机WIN7操作系统。
3.3流程图定义进程结构体：struct Pro{int num; //进程号int time_in; //进程到达时间int work_time; //进程服务时间int btime;//用于抢占式进程优先记录该进程开始时间int l_w_time;//用于抢占式进程优先记录剩余服务时间int end_time; //记录该进程结束时间，（需要时时监测）int judge; //用于需要时的标记}pro[10]; //进程结构体1先到先服务算法描述：把所有进程按到达先后排序，每次取最先到的进程执行后淘汰，再取下一个，直到所有进程调度完毕。
操作系统之实验-作业调度
作业调度一、实习内容模拟批处理多道操作系统的作业调度。
二、实习目的每个用户请求计算机的一个计算任务叫做一个作业。
一个作业从初始数据到得到计算结果，要经过若干个步骤的相继执行。
例如，编辑、编译、运行等，其中每一个步骤称作一个作业步。
用户向系统提出作业加工的方式称作业控制方式，作业控制方式有两种：终端控制方式（又称直接控制方式或联机控制方式）和批处理控制方式（又称自动控制方式或脱机控制方式）。
在批处理控制方式下，用户采用系统提供的作业控制语言（JCL）写好作业说明书，说明作业加工的步骤。
操作员把一批作业组织成输入流，通过“预输入”手段使每个作业的信息（包括作业说明书、源程序、初始数据等）暂存在辅助存储器的“输入井”中。
批处理多道操作系统的作业管理有两个任务：作业调度和作业控制。
采用多道程序设计方法的操作系统，在系统中要经常保留多个运行的作业，以提高系统效率。
作业调度从系统已接纳的暂存在输入井中的一批作业中挑选出若干个可运行的作业，并为这些被选中的作业分配所需的系统资源。
对被选中运行的作业，必须按照它们各自的作业说明书规定的步骤进行控制。
本实习要求学生模拟作业调度的实现，了解作业调度在操作系统中的作用。
三、实习题目采用先来先服务算法和运行时间最短者优先算法模拟设计作业调度程序。
【提示】（1）作业调度程序负责从输入井选择若干个作业进入主存，为它们分配必要的资源，当它们能够被进程调度选中时，就可以占用处理器运行，作业调度选择一个作业的必要条件是系统中现有的尚未分配的资源可以满足该作业的资源需求。
但有进系统中现有的尚未分配的资源既可满足某个作业的要求也可以满足其它一些作业的要求，那么，作业调度必须按照一定的算法在这些作业中作出选择。
先来先服务算法是按照作业进入输入井的先后次序来挑选作业，先进入输入井的作业优先被挑选，当系统中现有的尚未分配的资源不能满足先进入输入井的作业时，那么顺序挑选后面的作业。
运行时间最短者优先算法总是按作业要求能满足的作业先进入主存执行。
操作系统实验报告作业调度
操作系统实验报告：作业调度1. 引言作业调度是操作系统中的一个重要概念，它涉及到如何合理地安排计算机系统中的作业执行顺序，以最大程度地提高系统的效率和性能。
本文将介绍作业调度的基本概念和主要算法，以及在实验中的应用。
2. 作业调度的概念作业调度是指根据一定的策略和算法，按照一定的顺序从作业队列中选取作业，将其分配给可用资源来执行的过程。
作业调度的目标是实现公平、高效的任务分配，以提高系统的整体性能。
3. 作业调度算法3.1 先来先服务（FCFS）先来先服务是最简单的作业调度算法，即按照作业提交的顺序来执行。
当一份作业到达系统后，它将被放入作业队列的末尾。
一旦当前执行的作业完成，系统将选择队列中的下一个作业来执行。
3.2 短作业优先（SJF）短作业优先算法是根据作业的执行时间来进行调度，执行时间越短的作业优先级越高。
当一个作业进入系统时，系统会检查队列中的所有作业，并选择执行时间最短的作业来执行。
3.3 优先级调度优先级调度算法是根据作业的优先级来进行调度，优先级越高的作业优先级越高。
每个作业都会被分配一个优先级值，系统会按照优先级从高到低的顺序来执行作业。
3.4 时间片轮转调度时间片轮转调度算法将作业分为多个时间片，每个时间片的执行时间相等。
当一个作业进入系统时，系统会分配给它一个时间片，如果在时间片内作业没有完成，则将其放回队列的末尾，并执行下一个作业。
4. 实验中的应用在操作系统实验中，作业调度是一个重要的实验内容。
通过实验，我们可以深入了解不同调度算法的特点和适用场景。
实验中，我们可以使用模拟器来模拟作业调度的过程。
我们可以创建一个作业队列，然后使用不同的调度算法来执行这些作业，并记录它们的执行时间和系统的吞吐量。
通过实验，我们可以比较不同算法在不同场景下的表现，选择最适合当前系统的作业调度算法。
5. 结论作业调度是一个重要的操作系统概念，它决定了系统的性能和效率。
在本文中，我们介绍了作业调度的基本概念和常用算法，并讨论了在实验中的应用。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
课程设计报告课程名称操作系统课题名称作业调度模拟专业通信工程班级学号姓名指导教师2012年6月29 日课程设计任务书课程名称操作系统课题作业调度模拟任务书下达日期2012 年6 月24 日任务完成日期2012 年6 月29 日《操作系统》课程设计任务书一、课程设计的性质与目的操作系统课程设计是集中实践性环节之一，是学习完《操作系统》课程后进行的一次全面的综合练习。
要求学生达到熟练掌握操作系统的基本理论知识；掌握不同的调度算法；能够利用所学的基本编程知识，实现课程章节中涉及到的一些基本算法，从而加深理论知识的理解。
二、设计要求1 要求利用高级程序设计语言编程完成相关算法；2 程序具有清晰易懂的界面，有图形界面更佳；3 程序具备要求的基本功能模块；4 最终结果是能够运行的完整程序；5 最后给出课程设计报告三、课程设计报告要求1 统一封面（本任务书附带）、设计题目、设计要求以及系统功能需求分析；2 总体设计：包括系统总体设计框架和系统功能模块图；3 详细设计。
包括主要功能模块的算法设计思路以及对应的工作流程图；4 主要源程序代码，并附有注释；5 总结。
包括课程设计过程中的学习体会与收获、对操作系统和本次课程设计的认识等内容。
6 附录(完整源程序清单):可以是手写或打印稿(注意:不能和其他同学一样)7 报告最后附上评分表（见任务书末页）四、检查要求：1 每个人至少选作一题，学号末尾2位对5取余，余数对应的题号就是每个人必做题。
必须有可运行的程序，每个人要通过答辩；2 每个人必须交《操作系统课程设计报告》（打印稿）五、评分1 根据平时上机考勤，且每个人必须自己动手编写程序，不得抄袭；2 根据程序运行结果；3 学生能熟练地解释清楚指导老师对自己程序的提问；4 课程设计报告完成的质量和规范；六、时间、地点安排七、课程设计题目0. 进程调度算法的设计设计要求：A.设计进程控制块PCB表结构，分别适用于优先数调度算法和循环轮转调度算法。
B.建立进程就绪队列。
对两种不同算法编制入链子程序。
C.编制两种进程调度算法：1）优先数调度；2）循环轮转调度1. 银行家算法设计设计要求：编制银行家算法通用程序，并检测所给状态的系统安全性。
2．题目：页面置换算法模拟设计设计要求：计算并输出下述各种算法在不同内存容量下的命中率。
A.FIFO先进先出的算法B.LRR最近最少使用算法C.OPT最佳淘汰算法（先淘汰最不常用的页地址）D.LFR最少访问页面算法E.NUR最近最不经常使用算法3．题目：可变内存管理模拟设计要求：A.功能：内存初始化；分配作业内存；回收内存；显示作业列表；显示空闲内存。
B.编制两种内存分配算法：1）最佳适应算法；2）最坏适应算法。
4．题目：作业调度模拟设计要求：A.加深对作业概念地理解。
B.掌握短作业优先调度算法。
C.深入了解批处理系统如何组织作业、管理作业和调度作业。
D.了解作业控制块的作用，以及作业控制块的内容和组织方式。
目录一、系统功能需求分析 (7)二、系统总体设计 (7)1、设计的基本原理 (7)2、系统的总体框架设计 (7)3、系统功能模块图 (8)三、系统详细设计 (9)1、系统总体详细设计 (9)2、系统各模块详细设计 (10)（1）主函数模块 (10)（2）创建JCB作业控制块 (11)（3）信息输入模块 (11)（4）随机产生作业到达时间和服务时间模块 (12)（5）计算模块 (12)（6）对比模块 (13)（7）信息输出模块 (15)四、运行结果及结果分析 (15)1、运行结果 (15)2、运行结果分析 (17)五、总结 (18)六、附录 (19)七、评分表 ............................................... 错误!未定义书签。
一、系统功能需求分析作业调度是对成批进入系统的用户作业，根据作业控制块的信息，按一定的策略选取若干个作业使它们可以去获得处理器运行的一项工作。
而对每个用户来说总希望自己的作业的周转时间是最小的，短作业优先（SJF）便是其中一种调度方法。
本设计是为了加深对作业概念的理解，掌握短作业优先（SJF）调度算法，深入了解批处理系统如何组织作业、管理作业和调度作业，了解作业控制块的作用，以及作业控制块的内容和组织方式。
为了将系统中的作业组织起来，需要为每个进入系统的作业建立档案以记录和作业相关的信息，例如作业名、作业所需资源、作业执行时间、作业进入系统的时间、作业信息在存储器中的位置、指向下一个作业控制块的指针等信息。
这个记录作业相关信息的数据块称为作业控制块（JCB），并将系统中等待作业调度的作业控制块组织成一个队列，这个队列称为后备队列。
一个作业全部信息进入系统后，就为其建立作业控制块，并挂入后备队列。
当进行作业调度时，从后备队列中查找选择作业。
在从后备队列中查找选择作业是，先根据作业控制块中的信息，选中一个短作业，也就是执行时间最短的作业，将它们调入内存运行。
二、系统总体设计1、设计的基本原理在多道程序环境下，将系统中的作业组织起来，为每个进入系统的作业建立档案以记录和作业相关的信息，建立作业控制块（JCB）挂入后备队列。
进行作业调度时，在其后计算出各个作业的开始执行时间、完成时间、周转时间和平均周转时间，根据作业控制块中的信息，审查系统能否满足用户作业的资源需求，利用短作业优先算法进行作业调度，从外存的后备队列中选取某些作业调入内存，为它们创建进程、分配必要的资源并按照由小到大的顺序显示出来。
短作业优先的调度算法是从后备队列中选择一个或者若干个估计运行时间最短的作业，将它们调入内存运行。
2、系统的总体框架设计编写程序完成批处理系统中的作业调度，要求采用短作业优先的作业调度算法，其包括：首先确定作业控制块的内容和组成方式，然后完成作业调度，最后编写主函数对所作工作进程测试。
具体包括以下模块：信息输入模块，随机产生作业到达时间和服务时间模块，计算模块，比较模块，输出模块。
3、系统功能模块图系统功能模块图如下所示：三、系统详细设计1、系统总体详细设计系统设计流程图如下：2、系统各模块详细设计（1）主函数模块主函数模块调用各子模块，包括信息输入模块，随机产生作业到达时间和服务时间模块，计算模块，比较模块，输出模块，进而完成作业调度模拟功能。
其函数代码如下所示：int main(){while(1){system("CLS");int N;printf("\t\t\t*******欢迎使用作业调度模拟系统*********\n");printf("\t\t\t****************************************\n");printf("\t\t\t**********短作业优先调度算法************\n");printf("\t\t\t****************************************\n");printf("\t\t\t********非常感谢您的使用，谢谢！********\n");printf("请输入作业数目:");scanf("%d",&N);char ch;if(N>MAX){printf("\t!!输入的作业数目太大,请输入不大于%d的整数\n",MAX); printf("按Q或者q退出程序,按其他任意键继续测试...");ch = getch();if(ch=='Q'||ch=='q'){break;}else continue;}input(a,N);jcb *b=a;jcbf(b,N);printf("按Q或者q退出程序,按其他任意键继续测试...");ch = getch();if(ch=='Q'||ch=='q'){break;}}return 0;}（2）创建JCB作业控制块创建作业控制块JCB，定义为结构体，为进入系统的作业建立档案，其中定义了作业名，作业到达时间，作业服务时间，作业开始执行时间，作业完成时间，作业周转时间，作业平均周转时间，实现对作业的存储和管理。
结构体定义如下所示：struct jcb{char name[10]; //作业名float arrivetime; //作业到达时间float servicetime;//作业服务时间float starttime; //作业开始执行时间float finishtime; //作业完成时间float cyctime; //作业周转时间float avecyctime; //作业平均周转时间};（3）信息输入模块定义一定范围内可变输入数，用户只需输入可变范围内的数据即可进行作业信息的输入，如果输入的作业数超出其可变范围，则需重新输入。
其流程如下：（4）随机产生作业到达时间和服务时间模块此模块主要是利用随机函数srand()和rand()，以时间作为种子，随机产生作业到达时间和作业服务时间，这样便充分符合了短作业优先调度算法的特点。
（5）计算模块此模块是利用函数来实现对作业数据的计算，包括：计算各个作业的作业开始执行时间，作业完成时间，作业周转时间，作业平均周转时间。
其中作业执行时间为上个作业的完成时间，作业完成时间为作业执行时间加上作业服务时间，作业周转时间为作业被提交给系统开始，到作业完成为止的这段时间间隔，作业平均周转时间为作业周转时间除以服务时间。
其函数代码如下所示：void deal(jcb *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &avecyctime,int N){int k;for(k=0;k<=N-1;k++){if(k==0){p[k].starttime=p[k].arrivetime;p[k].finishtime=p[k].arrivetime+p[k].servicetime;}else{p[k].starttime=p[k-1].finishtime;p[k].finishtime=p[k-1].finishtime+p[k].servicetime;}}for(k=0;k<=N-1;k++){p[k].cyctime=p[k].finishtime-p[k].arrivetime;p[k].avecyctime=p[k].cyctime/p[k].servicetime;}}（6）对比模块此模块主要是利用函数将不同用户在计算模块得到的数据（完成时间）进行比较，以便由小到大输出作业名，作业到达时间，作业服务时间，作业开始执行时间，作业周期时间，作业平均周转时间。