青岛理工大学
操作系统课程设计报告
院（系）：计算机工程学院
专业：计算机科学与技术专业
学生姓名:
班级：＿＿学号:
题目：短作业优先调度算法的进程调度程序＿
起迄日期:＿＿＿＿＿＿＿＿
设计地点:
指导教师:
2011—2012年度第 1 学期
完成日期: 2012 年 1 月日
一、课程设计目的
进行操作系统课程设计主要是在学习操作系统课程的基础上，在完成操作系统各部分实验的基础上，对操作系统的整体进行一个模拟，通过实践加深对各个部分的管理功能的认识，还能进一步分析各个部分之间的联系，最后达到对完整系统的理解。同时，可以提高运用操作系统知识解决实际问题的能力；锻炼实际的编程能力、开发软件的能力；还能提高调查研究、查阅技术文献、资料以及编写软件设计文档的能力。
二、课程设计内容与要求
设计目的：在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个，且进程之间也存在着同步与互斥的关系，要求采用指定的调度策略，使系统中的进程有条不紊地工作，通过观察诸进程的运行过程，以巩固和加深处理机调度的概念。
2、设计要求（多道、单处理机）：
1)每一个进程有一个PCB，其内容可以根据具体情况设定。
2)可以在界面设定的互斥资源（包括两种：输入设备与输出设备）的数目
3)进程数、进入内存时间、要求服务时间可以在界面上进行设定
4)进程之间存在一定的同步与互斥关系，可以通过界面进行设定，其表示方法如下：
进程的服务时间由三段组成：I2C10O5（表示进程的服务时间由2个时间片的输入，10个时间片的计算，5个时间片的输出）
进程间的同步关系用一个段表示：W2，表示该进程先要等待P2进程执行结束后才可以运行
因此，进程间的同步与互斥关系、服务时间可以统一用四段表示为：I2C10O5W2
5)可以在运行中显示各进程的状态：就绪、阻塞、执行
6)采用可视化界面，可在进程调度过程中随时暂停调度，查看当前进程的状态以及相
应的阻塞队列
7)具有一定的数据容错性
三、系统分析与设计
1、系统分析
本系统主要是采用短作业优先算法进程的进程调度过程。短作业优先调度算法，是指对短作业或短进程优先调度的算法。他们可以分别用于作业调度和进程调度，短作业优先的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将他们调入内存运行。而短进程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给他，，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再度重新调度。本程序采用了非抢占式短作业优先调度。而非抢占式这种方式，一旦把处理机分配给某进程后，便让该进程一直执行，直至该进程完成或发生某事件而被阻塞时，才再把处理机分配给其它进程，决不允许某进程抢占已经分配出去的处理机。这种调度方式的优点是实现简单，系统开销小，适用于大多数的批处理系统环境。但它难以满足紧急任务的要求——立即执行，因而可能造成难以预料的后果。因此，在要求比较严格的实时系统中，不宜采用这种调度方式本系统的主要是在满足要求多道单处理机的情况下进行短作业的优先调度。
本系统在测试时输入了五个进程，按实验要求如I2C10O5（表示进程的服务时间由2个时间片的输入，10个时间片的计算，5个时间片的输出，5个时间片的计算组成）的方式输入，各进程的信息如下：（0 0 1 1 1 ）（1 2 1 2 2 ）（2 4 1 1 1 ）
（3 6 2 1 1 ）（4 8 1 0 1），其中括号内第一个数字代表进程标识，第二个数字代表进程的到达时间，第三的字符串则代表的是服务时间，由此可得五个进程的服务时间分别为3,6,4,5,2。
进程进入内存，则按照优先级进行执行进程。主要是实现了进程执行过程的界面演示以及在暂停演示时各进程此时的状态，主要包括三种状态——就绪、执行、阻塞。同时，在暂停执行时可以查看当前时间的阻塞队列。其中进程执行界面的演示过程中用到了坐标轴，x 轴代表时间，y轴代表进程的标志（默认进程标志为0，1,2,3,4……n-1,n表示进程的个数，在计数过程中按进程的到达时间开始计数），用灰色表示一个时间片，每个进程的执行过程即可表示为时间片不断增加的过程。
下面是进程信息的输入界面，界面介绍如下：
需要录入的进程数：输入需要执行的进程的个数。
保存文件：输入数据后将自动保存进程信息，保存在txt文件中，因此输入你要
保存的txt文件的名子，或者在输入进程信息时直接输入已保存的txt文件名
（不包括扩展名.txt）便可直接点击“录入完毕”按钮，进行后续操作。
输入设备数目：主要是输入输入设备的数目。
输出设备数目：主要是输入输出设备的数目。
进入内存的时间：表示进程的到达时间。
要求服务时间：进程的服务时间由四段组成：I2C10O5（表示进程的服务时间由2个时
间片的输入，10个时间片的计算，5个时间片的输出），按此格式输入信息，
如若没有其中一步如没有计算这一步表示有0个时间片的计算，服务时间可
以表示为I2C105 。以此格式输入进程的服务时间。
“录入第1个数据“按钮：当你输入完毕第一个数据时，点击此按钮，进入第二个进程数
据信息的录入。
“录入完毕进行演示“按钮：当你将所有进程的信息输入完毕后点击此按钮。进入演示界面
进行演示。
“退出“按钮：在执行此界面的任何时刻均可点击此按钮，退出此界面。
录入完毕点击按钮“录入完毕进行执行”后便会弹出进程的执行演示界面如下：
右上角带颜色的三个矩形分别表示进程的执行状态，蓝色矩形代表进程正在执行，绿色矩形代表进程已经执行完成，红色矩形则代表进程受到阻塞。
“开始演示“按钮：点击此按钮则开始演示进程的执行过程。
“暂停演示“按钮：点击此按钮则暂停进程的演示过程。
“重新开始“按钮：点击此按钮则重新演示进程的执行过程。
“退出界面“按钮：点击此按钮则退出演示界面。
“查看阻塞队列”按钮：在点击“暂停演示”按钮之后，点击此按钮，可查看此时的阻塞队
列。
1、系统设计
本调度算法在设计的时候主要运用了四个类库。PCB类库主要是包括了要运用到得相关类有三个，Process类主要是声明了进程的相关属性以及方法结构体，GetProcess 和SetProcess类主要是对进程相关属性进行处理。Scheduling类库主要是实现短作业优先调度，同样包括三个类，BlockQueue类主要是实现对阻塞队列的处理，Rank类主要是实现按进程的优先级进行排序实现进程的短作业优先调度，SJF类主要是为了实现进程执行演示的方便设计的一个类，它声明了一个数组，将每个时刻的进程作为数组元素放入数据组中。Used类库主要是对演示界面的处理，里面包括一个类Drawing,这个
类主要是完成对演示界面所运用到得坐标轴的实现。最后一个类库为短作业优先调度演示程序，主要包含了AddFrom和ShowFrom两个类，这两个类主要是实现程序界面的设计，以及相关控件事件的连接以及实现。
在本程序中主要运用的数据结构是数组，如Process[]数组主要使用了存放进来的进程（存放顺序按进程的到达时间，为方便描述一下均简写为P[]），block[]数组用来存放阻塞队列，exeQ[]是将进程按短作业优先级排序后的数组，okP[]数组则是某一时刻到达的所有进程所形成的数组，以上数组均已进程作为数组元素。
短作业优先调度流程图如下：
短作业优先调度
阻塞队列的流程图如下：
阻塞队列进程调度演示流程图：
进程调度演示
四、系统测试与调试分析
1、系统测试
本程序主要是采用功能测试，对程序进行的相关的测试与分析。共输入五个进程信息，输入设备和输出设备各输入一个然后分别输入各进程的到达时间和服务时间，分别如下：（0 1 1 1 ）（2 1 2 2 ）（4 1 1 1 ）（6 2 1 1 1）（8 1 0 1）。再输入过程中，进程的个数、到达时间以及输入设备和输出设备的个数分别是整数，否则将提示输入错误。进程的服务时间必须严格按照要求来填写，否则将提示输入错误。
由此可得五个进程的执行顺序为：3,6,4,5,2。
2、调试分析
在调试本程序时和演示过程中，出现了不少的错误。其中在编写短作业优先调度算法的代码中，用到了不少的for循环以及for循环的嵌套，在这部分出现了变量的混淆，大括号的缺失或多余，经过检查后改正。在编写短作业优先算法代码的时候，出现了思路紊乱，算法思路不清晰，不能够完成短作业的优先，后经请教同学以及通过画相关流程图得到解决。还有由于对c#的运用并不熟练以及对c#的可视化界面的制作不太了解，使自己在做程序过程中遇到了很大的阻力，后经过翻看相关书籍以及请教同学，解决的这个问题。
本程序的演示界面做的很简陋，只是简单的实现了非抢占式的短作业优先调度，但是在本程序的功能中有一项实现输入设备和输出设备只是实现了设备数目的输入功能，但是没有实现设备之间的互斥问题。因此，本程序无论是在界面还是在功能上均有很大的缺点和不足之处，需要不断的改进和完善。
五、用户手册
1、程序的编写是在win7系统下的VS2010成的。
2、由于电脑系统里已经安装了vs2010此不需要再进行安装。
3、使用本程序界面的步骤。
（1）运行本程序会弹出界面如图5-1：
图5-1
（2）在以上弹出的界面上输入进程的数目以及保存的文件名和输入设备和输出设备的数目。然后输入第一个进程的进入内存的时间和要求服务的时间。如图5-2：
图5-2
（3）点击“录入第1个数据”按钮，弹出以下窗口，开始输入第二个数据的进入内存的时间和要求服务的时间。如若输入的数据格式正确，则会弹出图5-3：
图5-3
点击确定按钮，进入下一个数据的输入图5-4：
图5-4
如此依次输入所有进程的相关信息，直到所有的进程信息都输入完毕。
如若输入数据不正确则会弹出窗口图5-5：
图5-5
点击确定重新输入正确的进程信息。
（4）当将所有的进程信息都输入完毕后，点击“录入完毕进行演示”按钮。则会弹出演示界面图5-6：
图5-6
（5）点击开始演示按钮，进程开始执行。演示状态如图5-7：
图5-7
（6）点击暂停按钮，演示暂停，进程停止执行，此时可查看各进程的状态图5-8。
图5-8
（7）在暂停的情况下，点击“查看阻塞队列”按钮。则会弹出以下窗口，并显示此刻的阻塞队列。如图5-9：
图5-9
（8）如果想重新演示，可以点击“重新开始”按钮。当演示完毕后，可以点击“退出界面”按钮。退出演示界面。
六、程序清单
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace QD.Mg.Winform.Process
public class Process
{
static int num = 0;
private int privatePcb;//程序内部使用的PCB
public int PrivatePcb
{
get { return privatePcb; }
set { privatePcb = value; }
}
private int enteringTime;//进入内存的时间
public int EnteringTime
{
get { return enteringTime; }
set { enteringTime = value; }
}
private double serviceTime;//要求服务的时间
public double ServiceTime
{
get { return serviceTime; }
set { serviceTime = value; }
}
public Process()
{
privatePcb = num++;
enteringTime = -1;
serviceTime = -1;
}
///
///重载的方法
///
///
public override string ToString()
{
return privatePcb + "|" + enteringTime + "|" + serviceTime ; }
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
namespace QD.Mg.Winform.Process
public class SetProcess
{
private static bool save(string filePosition,string content)
{
try
{
StreamWriter sw = new StreamWriter(filePosition, true, System.Text.Encoding.Default);//在原有的基础上添加
sw.Write(content);
sw.Close();
}
catch(IOException e)
{
Console.WriteLine(e.Message);
return false;
}
return true;
}
public static int setProcesses(string filePosition,Process p)
{
//将Process中的每个进程对象都拼接成一个string字符串，存放到txt文件中
string saveString = p.ToString();
saveString = saveString + "\r\n";//在字符串的最后加上换行的标志//调用save函数，实现存储
save(filePosition, saveString);
return 0;
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Text.RegularExpressions;
namespace QD.Mg.Winform.Process
{
public class GetProcess
{
public static Process[] getProcesses(string filePosition)
{
string content = read(filePosition);
string []childString = content.Split(new
string[]{"\r\n"},StringSplitOptions.RemoveEmptyEntries);
//
Process[] process = new Process[childString.Length];
for (int i = 0; i < process.Length;i++ )
{
process[i] = new Process();
}
for (int i = 0; i < process.Length; i++)
{
//将一个进程的转化成对应的类
string[] grandsonString = childString[i].Split('|');
//为各个变量赋值
process[i].PrivatePcb = Convert.ToInt32(grandsonString[0]);
process[i].EnteringTime = Convert.ToInt32(grandsonString[1]); process[i].ServiceTime = Convert.ToInt32(grandsonString[2]);
}
return process;
}
private static string read(string filePosition)
{
FileStream fs = new FileStream(filePosition, FileMode.Open, FileAccess.Read);
StreamReader sr = new StreamReader(fs, Encoding.Default);
string content = sr.ReadToEnd();
sr.Close();
return content;
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace QD.Mg.Winform.Scheduling
{
///
///阻塞队列的处理函数
///
public class BlockQueue
{
public static Process.Process[] getBlockQueue(int time, Process.Process[] process)
{
#region变量初始化
Process.Process[] block = new
QD.Mg.Winform.Process.Process[process.Length];//阻塞队列数组
Process.Process[] exeQ;//每个算法的执行顺序
Process.Process[] okP;//给定时间内到达的进程
int num = 0;//阻塞队列的下标
int okPNumber = 0;
int isFinish = -1;//完成的进程的最后一个的下标
int isFinishTotalServiceTime = 0;//完成进程的总的服务时间
#endregion
#region SJF 短作业优先调度算法
//首先获取得到执行的序列
exeQ = Rank.getRank(process);
//符合条件的
okP = new QD.Mg.Winform.Process.Process[process.Length];
#region获取得到给定时间内到达的进程，进行阻塞队列的计算for (int i = 0; i < exeQ.Length; i++)
{
if (exeQ[i] != null && exeQ[i].EnteringTime <= time)
{
okP[okPNumber++] = exeQ[i];
}
}
#endregion
#region获取已经执行完了的进程的标志已经执行完了的总的服务时间for (int i = 0; i < okP.Length; i++)
{
if (okP[i] != null)
{
isFinishTotalServiceTime = isFinishTotalServiceTime + Convert.ToInt32(okP[i].ServiceTime);
if (isFinishTotalServiceTime > time)
{
isFinish = i - 1;
break;
}
}
}
#endregion
#region去除不符合条件的
for (int j = 0; j < isFinish + 2; j++)
{
okP[j] = null;
}
#endregion
#region将okP中的非空值，按照在数组中的顺序，存入阻塞数组中
for (int i = 0; i < okP.Length; i++)
{
if (okP[i] != null)
{
block[num++] = okP[i];
}
}
#endregion
#endregion
return block;
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace QD.Mg.Winform.Scheduling
{
public class Rank
{
public static Process.Process[] getRank(Process.Process[] process)
{
//首先按照进入时间排序，然后根据服务时间对排序进行调整
#region按照进入时间进行排序
Process.Process temp;
for (int i = 0; i < process.Length - 1; i++)
{
for (int j = i + 1; j < process.Length; j++)
{
if (process[i].EnteringTime > process[j].EnteringTime) {
temp = process[i];
process[i] = process[j];
process[j] = temp;
}
}
}
#endregion
for (int i = 0; i < process.Length; i++)
{
//获取前面一段的要求服务总时间
int totalServiceTime = 0;
for (int x = 0; x <= i; x++)
{
totalServiceTime = totalServiceTime +
Convert.ToInt32(process[x].ServiceTime);
}
//找到要处理的进程数组，即在前一个进程处理时间内到达的进程 Process.Process[] front = new
QD.Mg.Winform.Process.Process[process.Length];//注意空值
for (int j = i + 1; j < process.Length; j++)
{
if (Convert.ToInt32(process[j].EnteringTime) < totalServiceTime)
{
front[j] = process[j];
}
}
#region将front中的非空数据
Process.Process m;
for (int ii = 0; ii < front.Length - 1; ii++)
{
for (int j = ii + 1; j < front.Length; j++)
{
//
if (front[ii] != null && front[j] != null)
{
if (front[ii].ServiceTime >
front[j].ServiceTime)//将作业大的排在后面，实现短作业优先
{
m = front[ii];
front[ii] = front[j];
front[j] = m;
}
}
}
}
//将front中的非空数据，覆盖process中的相应位置的数据
for (int a = 0; a < front.Length; a++)
{
if (front[a] != null)
{
process[a] = front[a];
}
}
}
return process;
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace QD.Mg.Winform.Scheduling
{
public class SJF
{
public static int[] getExecuteQueue(Process.Process[] process)
{
int totalServiceTime = 0;
for (int i = 0; i < process.Length; i++)
{
totalServiceTime = totalServiceTime +
Convert.ToInt32(process[i].ServiceTime);
}
int[] executeQueue = new int[totalServiceTime];
int tips = 0;
Process.Process[] exequeue = Rank.getRank(process);
for (int i = 0; i < exequeue.Length; i++)
{
for (int j = 0; j < exequeue[i].ServiceTime; j++)
{
executeQueue[tips++] = exequeue[i].PrivatePcb;
}
}
return executeQueue;
}
}
}
七、体会与自我评价
短作业优先调度算法，是指对短作业或短进程优先调度的算法。他们可以分别用于作业调度和进程调度，短作业优先的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将他们调入内存运行。而短进程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给他，，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再度重新调度。本程序采用了非抢占式短作业优先调度。而非抢占式
这种方式，一旦把处理机分配给某进程后，便让该进程一直执行，直至该进程完成或发生某事件而被阻塞时，才再把处理机分配给其它进程，决不允许某进程抢占已经分配出去的处理机。这种调度方式的优点是实现简单，系统开销小，适用于大多数的批处理系统环境。但它难以满足紧急任务的要求——立即执行，因而可能造成难以预料的后果。因此，在要求比较严格的实时系统中，不宜采用这种调度方式本系统的主要是在满足要求多道单处理机的情况下进行短作业的优先调度。
在做课程设计的过程中，我渐渐发现了自己的许多不足之处。比如，对短作业优先调度的原理了解不透彻，对课本知识掌握不熟练，以至在做的过程中需要不断的去翻阅资料和课本，大大降低了制作课设的效率。但正是这样，通过这次短作业优先调度课设，使我更加深刻的理解了短作业优先调度的过程以及工作原理，同时也加深了我对其他进程的理解及原理的掌握，让我对操作系统的知识有了新的认识和感悟，加深了我对课本知识的掌握和理解。同时让我认识到自己的不足之处，自己对课本知识的掌握不透彻，对许多知识点一知半解之后便作罢，缺乏刻苦钻研的认真而又耐心思考问题的习惯，在以后的学习中我会不断的努力，并努力改正这些缺点。其次，由于自己在编写程序的过程中，遇到了不少的问题，体现了自己编程的生疏不熟练，在一些细节问题上会出现一些小错误，反映了自己对编程许多规则和细节问题上的生疏以及自己的粗心大意的问题，因此在以后的学习之中，应注重自己的动手编程能力，勤加练习，努力做到熟能生巧，同时注重培养自己独立思考问题的能力，在遇到问题面前能够认真努力的思考一番之后在进行处理而不是手忙脚乱的不知所措。这些对我以后的学习将会有很大的帮助，不仅能够让我认识到自己的缺点并督促我改正，同时还能够让我养成许多学习的好习惯，使自己能够跟好的学习和掌握专业知识。我相信，在以后的学习中，我一定会更加努力认真，掌握好专业知识，并提高动手能力和自我解决问题的能力，使自己变的更好。
八、参考文献
【1】汤子瀛编著，计算机操作系统（修订版），西安电子科技大学出版社，2001年
【2】赵会东王军等编著，C#项目开发案例全程实录（第二版），清华大学出版社，2011年
【3】传智播客.net就业精品培训录像下载地址：https://www.doczj.com/doc/155127745.html, 【4】《初学Visual C# 2010》下载地址：https://www.doczj.com/doc/155127745.html, 【5】《https://www.doczj.com/doc/155127745.html,程序开发范例宝典(C#)(第2版)》下载地址：
https://www.doczj.com/doc/155127745.html,
九、课程设计评价
青岛理工大学 操作系统课程设计报告 院（系）：计算机工程学院 专业：计算机科学与技术专业 学生姓名: 班级：＿＿学号: 题目：短作业优先调度算法的进程调度程序＿ 起迄日期:＿＿＿＿＿＿＿＿ 设计地点: 指导教师: 2011—2012年度第 1 学期 完成日期: 2012 年 1 月日
一、课程设计目的 进行操作系统课程设计主要是在学习操作系统课程的基础上，在完成操作系统各部分实验的基础上，对操作系统的整体进行一个模拟，通过实践加深对各个部分的管理功能的认识，还能进一步分析各个部分之间的联系，最后达到对完整系统的理解。同时，可以提高运用操作系统知识解决实际问题的能力；锻炼实际的编程能力、开发软件的能力；还能提高调查研究、查阅技术文献、资料以及编写软件设计文档的能力。 二、课程设计内容与要求 设计目的：在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个，且进程之间也存在着同步与互斥的关系，要求采用指定的调度策略，使系统中的进程有条不紊地工作，通过观察诸进程的运行过程，以巩固和加深处理机调度的概念。 2、设计要求（多道、单处理机）： 1)每一个进程有一个PCB，其内容可以根据具体情况设定。 2)可以在界面设定的互斥资源（包括两种：输入设备与输出设备）的数目 3)进程数、进入内存时间、要求服务时间可以在界面上进行设定 4)进程之间存在一定的同步与互斥关系，可以通过界面进行设定，其表示方法如下： 进程的服务时间由三段组成：I2C10O5（表示进程的服务时间由2个时间片的输入，10个时间片的计算，5个时间片的输出） 进程间的同步关系用一个段表示：W2，表示该进程先要等待P2进程执行结束后才可以运行 因此，进程间的同步与互斥关系、服务时间可以统一用四段表示为：I2C10O5W2 5)可以在运行中显示各进程的状态：就绪、阻塞、执行 6)采用可视化界面，可在进程调度过程中随时暂停调度，查看当前进程的状态以及相 应的阻塞队列 7)具有一定的数据容错性 三、系统分析与设计 1、系统分析 本系统主要是采用短作业优先算法进程的进程调度过程。短作业优先调度算法，是指对短作业或短进程优先调度的算法。他们可以分别用于作业调度和进程调度，短作业优先的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将他们调入内存运行。而短进程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给他，，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再度重新调度。本程序采用了非抢占式短作业优先调度。而非抢占式这种方式，一旦把处理机分配给某进程后，便让该进程一直执行，直至该进程完成或发生某事件而被阻塞时，才再把处理机分配给其它进程，决不允许某进程抢占已经分配出去的处理机。这种调度方式的优点是实现简单，系统开销小，适用于大多数的批处理系统环境。但它难以满足紧急任务的要求——立即执行，因而可能造成难以预料的后果。因此，在要求比较严格的实时系统中，不宜采用这种调度方式本系统的主要是在满足要求多道单处理机的情况下进行短作业的优先调度。 本系统在测试时输入了五个进程，按实验要求如I2C10O5（表示进程的服务时间由2个时间片的输入，10个时间片的计算，5个时间片的输出，5个时间片的计算组成）的方式输入，各进程的信息如下：（0 0 1 1 1 ）（1 2 1 2 2 ）（2 4 1 1 1 ）
学号： 姓名： 班级： 实验时间： 2011-10-10 实验编号 002 实验名称 作业调度算法 实验目的和 要求 通过对作业调度算法的模拟加深对作业概念和作业调度算法的理解 实验内容 （1） 模拟FCFS 算法实现作业调度 （2） 模拟短作业优先算法实现作业调度 模拟最高相应比优先算法实现作业调度 一、 实验题目 输入：作业流文件，其中存储的是一系列要执行的作业， 每个作业包括三个数据项： 作业号、作业进入系统的时间（用一小数表示，如10：10，表示成10.10）、估计执行时间（单位小时，以十进制表示） 参数用空格隔开，下面是示例： 1 8.00 0.5 2 8.15 0.3 3 8.30 0.25 4 8.35 0.20 5 8.45 0.15 6 9.00 0.10 7 9.20 0.05 其中调度时刻为最后一个作业到达系统的时间！ 输出：作业号 进入内存的时间，每行输出一个作业信息。 并输出每一种调度算法的平均周转时间和平均带权周转时间。 二、 算法设计思路 首先用一个switch 函数做界面选择进入哪一种算法。用一个内来定义作业 float s;//提交时间 float j;//执行时间 float k;//开始时间 float w;//完成时间 float z;//周转时间 float d;//带权周转时间 1， 先来先服务，首先计算第一个作业的完成时间，周转时间，带权周转时间。再用for 循 环来计算剩下每一个作业的完成时间，周转时间，带权周转时间。然后再算出平均周转时间和平均带权周转时间。 2， 短作业有优先，首先计算第一个作业的完成时间，周转时间，带权周转时间。再用来计 算其他作业的。其中在for 循环中嵌套while 函数，在每一次计算前判断处于等待状态 计算机操作系统 实验报告
《操作系统》实验报告 题目：作业调度算法 班级：网络工程 姓名：朱锦涛 学号：E31314037
一、实验目的 用代码实现页面调度算法，即先来先服务（FCFS）调度算法、短作业优先算法、高响应比优先调度算法。通过代码的具体实现，加深对算法的核心的理解。 二、实验原理 1.先来先服务（FCFS）调度算法 FCFS是最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，系统将按照作业到达的先后次序来进行调度，或者说它是优先考虑在系统中等待时间最长的作业，而不管该作业所需执行的时间的长短，从后备作业队列中选择几个最先进入该队列的作业，将它们调入内存，为它们分配资源和创建进程。然后把它放入就绪队列。 2.短作业优先算法 SJF算法是以作业的长短来计算优先级，作业越短，其优先级越高。作业的长短是以作业所要求的运行时间来衡量的。SJF算法可以分别用于作业和进程调度。在把短作业优先调度算法用于作业调度时，它将从外存的作业后备队列中选择若干个估计运行时间最短的作业，优先将它们调入内存。 3、高响应比优先调度算法
高响应比优先调度算法则是既考虑了作业的等待时间，又考虑了作业的运行时间的算法，因此既照顾了短作业，又不致使长作业等待的时间过长，从而改善了处理机调度的性能。 如果我们引入一个动态优先级，即优先级是可以改变的令它随等待的时间的延长而增加，这将使长作业的优先级在等待期间不断地增加，等到足够的时间后，必然有机会获得处理机。该优先级的变化规律可以描述为： 优先权 = （等待时间 + 要求服务时间）/要求服务时间 三、实验内容 源程序： #include
课程设计 采用短作业优先调度算法调度程序 学号： 姓名： 专业： 指导老师： 日期：
目录 一、实验题目 (3) 二、课程设计的目的 (3) 三、设计内容 (3) 四、设计要求 (3) 五、主要数据结构及其说明 (4) 六、程序运行结果 (5) 七、流程图 (7) 八、源程序文件 (9) 九、实验体会 (13) 十、参考文献 (13)
摘要 在多道程序环境下，主存中有着多个进程，其数目往往多于处理机数目。这就要求系统能按某种算法，动态地把处理机分配给就绪队列中的一个进程，使之执行。分配处理机的任务是由处理机调度程序完成的。由于处理机是最重要的计算机资源，提高处理机的利用率及改善系统性能（吞吐量、响应时间），在很大程度上取决于处理机调度性能的好坏，因而，处理机调度便成为操作系统设计的中心问题之一。 在多道程序系统中，一个作业被提交后必须经过处理机调度后，方能获得处理机执行。对于批量型作业而言，通常需要经历作业调度和进程调度两个过程后方能获得处理机。作业调度是对成批进入系统的用户作业，根据作业控制块的信息，按一定的策略选取若干个作业使它们可以去获得处理器运行的一项工作。而对每个用户来说总希望自己的作业的周转时间是最小的，短作业优先（SJF）便是其中一种调度方法。本次课程设计主要是模拟短作业优先(SJF)调度算法。
一、实验题目 采用短作业优先算法的的进程调度程序 二、课程设计的目的 操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合一起，独立分析和解决实际问题的机会。 进一步巩固和复习操作系统的基础知识。 培养学生结构化程序、模块化程序设计的方法和能力。 提高学生调试程序的技巧和软件设计的能力。 提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。 三、设计内容 设计并实现一个采用短作业优先算的进程调度算法演示程序 四、设计要求 1. 每一个进程有一个PCB，其内容可以根据具体情况设定。 2. 进程数、进入内存时间、要求服务时间、优先级等均可以在界面上设定 3. 可读取样例数据（要求存放在外部文件中）进行进程数、进入内存时间、时间片长度、进程优先级的初始化 4. 可以在运行中显示各进程的状态：就绪、执行（由于不要求设置互斥资源与进程间同步关系，故只有两种状态） 5. 采用可视化界面，可在进程调度过程中随时暂停调度，查看当前进程的状态以及相应的阻塞队列
《操作系统》实验一实验报告 【实验题目】：先来先服务FCFS和短作业优先SJF进程调度算法【实验目的】 通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。 【实验内容】 问题描述： 设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, …,T n时刻到达系统，它们需要的服务时间分别为S1, … ,S n。分别采用先来先服务FCFS和短作业优先SJF 进程调度算法进行调度，计算每个进程的完成时间，周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。 程序要求如下： 1）进程个数n；每个进程的到达时间T1, …,T n和服务时间S1, … ,S n；选择算法1-FCFS，2-SJF。 2）要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行，计算每个进程的周转时间，带权周转时间，并且计算所有进程的平均周转时间，带权平均周转时间； 3）输出：要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程B开始运行”等等； 4）输出：要求输出计算出来的每个进程的周转时间，带权周转时间，
所有进程的平均周转时间，带权平均周转时间。【实验过程】 #include
操作系统》实验一实验报告 【实验题目】：先来先服务FCFS 和短作业优先SJF进程调度算法【实验目的】 通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。 【实验内容】 问题描述： 设计程序模拟进程的先来先服务FCFS 和短作业优先SJF 调度过程。假设有n个进程分别在T1, ?,T n时刻到达系统，它们需要的服务时间分别为S1, ?,S n。分别采用先来先服务FCFS和短作业优先SJF 进程调度算法进行调度，计算每个进程的完成时间，周转时间和带权周转时间，并且统计n 个进程的平均周转时间和平均带权周转时间。 程序要求如下： 1）进程个数n；每个进程的到达时间T1, ?,T n 和服务时间S1, ?,S n；选择算法1-FCFS，2-SJF。 2）要求采用先来先服务FCFS 和短作业优先SJF分别调度进程运行，计算每个进程的周转时间，带权周转时间，并且计算所有进程的平均周转时间，带权平均周转时间； 3）输出：要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程 B 开始运行”等等；
4）输出：要求输出计算出来的每个进程的周转时间，带权周转时间， 所有进程的平均周转时间，带权平均周转时间 【实验过程】 #include 题目先来先服务FCFS和短作业优先SJF进程调度算法 姓名： 学号： 专业： 学院： 指导教师：林若宁 二零一八年十一月 一、实验目的 模拟单处理器系统的进程调度，分别采用短作业优先和先来先服务的进程调度算法作为进程设计算法，以加深对进程的概念及进程调度算法的理解． 二、实验内容 1. 短作业优先调度算法原理 短作业优先调度算法，是指对短作业或断进程优先调度的算法。它们可以分别可以用于作业调度和进程调度。短作业优先调度算法，是从后备队列中选择一个或若干个运行时间最短的作业，将它们调入内存运行。短进程优先调度算法，是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。 2. 先来先服务调度算法原理 先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。 三、程序设计 1.概要设计 程序包括主函数、FCFS算法函数、SJF算法函数、输出函数；主函数流程：输入文件中的数据—显示各进程数据—选择算法—调用相应算法的函数—输出结果 2.算法流程 SJF算法流程图： 3.详细设计 （1）定义一个结构体 typedef struct PCB { char job_id[10]; //作业ID float Arr_time; //到达时刻 float Fun_time; //估计运行时间 float Wait_time; //等待时间 float Start_time; //开始时刻 float Fin_time; //完成时刻 float Tur_time; //周转时间 float WTur_time; //带权周转时间 int Order; //优先标记 }list; （2）先来先服务算法函数 void fcfs(list *p,int count) //先来先服务算法 { list temp; //临时结构体变量int i; int j; 短作业（进程）优先调度算法 1.短作业（进程）优先调度算法SJ（P）F，是指对短作业或 短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。SJ(P)F 调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。该算法对长作业不利，完全未考虑作业的紧迫程度。 2.流程图 3.代码 #include<> #include<> #include<> struct sjf{ char name[10]; float arrivetime; float servicetime; float starttime; float finishtime; float zztime; float dqzztime; }; sjf a[100]; void input(sjf *p,int N) { int i; printf("intput the process's name & arrivetime & servicetime:\nfor exmple: a 0 100\n"); for(i=0;i<=N-1;i++) { printf("input the %dth process's information:\n",i+1); scanf("%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].servicetim e); 短作业优先调度算法 学院计算机科学与技术 专业 学号 学生姓名 指导教师姓名 2014-3-18目录 九参考文献……………………………………………………………………………………………………… 实验题目 采用短作业优先算法的进程调度程序 课程设计的目的 操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合一起，独立分析和解决实际问题的机会。 进一步巩固和复习操作系统的基础知识。 培养学生结构化程序、模块化程序设计的方法和能力。 提高学生调试程序的技巧和软件设计的能力。 提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。 设计内容 设计并实现一个采用短作业优先算的进程调度算法演示程序 设计要求 1. 每一个进程有一个PCB，其内容可以根据具体情况设定。 2. 进程数、进入内存时间、要求服务时间、优先级等均可以在界面上设定 3. 可读取样例数据（要求存放在外部文件中）进行进程数、进入内存时间、时间片长度、进程优先级的初始化 4. 可以在运行中显示各进程的状态：就绪、执行（由于不要求设置互斥资源与进程间同步关系，故只有两种状态） 5. 具有一定的数据容错性 主要数据结构及其说明 算法的简要说明：短作业（进程）优先调度算法SJ（P）F，是指对短作业或短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。优点是SJ(P)F调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。缺点是该算法对长作业不利；完全未考虑作业的紧迫程度，因而不能保证紧迫性作业（进程）长期不被调度；由于作业（进程）的长短只是根据用户所提供的估计执行时间而定的，而用户又可能会有意或无意地缩短其作业的估计运行时间，致使该算法不一定能真正做到短作业游戏那调度。 该程序定义了一个进程数据块(struct spf)，该数据块有进程名(name)、到达时间(arrivetime)、服务时间(servicetime)、开始执行时间(starttime)、完成时间 (finishtime)、周转时间(zztime)、带权周转时间(dqzztime)。用到的公式有：完成时间=到达时间+服务时间；周转时间=完成时间-到达时间；带权周转时间=周转时间/服务时间；(第一次执行的进程的完成时间=该进程的到达时间；下一个进程的开始执行时间=上一个进程的完成时间)。运行进程的顺序需要对进程的到达时间和服务时间进行比较。如果某一进程是从0时刻到达的，那么首先执行该进程；之后就比较进程的服务时间，谁的服务时间短就先执行谁（如果服务时间相同则看它们的到达时间，到达时间短的先执行）；如果到达时间和服务时间相同，则按先来先服务算法执行。 . 题目先来先服务FCFS和短作业优先SJF进程调度算法 姓名： 学号： 专业： 学院： 指导教师：林若宁 二零一八年十一月 一、实验目的 模拟单处理器系统的进程调度，分别采用短作业优先和先来先服务的进程调度算法作为进程设计算法，以加深对进程的概念及进程调度算法的理解． 二、实验内容 1. 短作业优先调度算法原理 短作业优先调度算法，是指对短作业或断进程优先调度的算法。它们可以分别可以用于作业调度和进程调度。短作业优先调度算法，是从后备队列中选择一个或若干个运行时间最短的作业，将它们调入内存运行。短进程优先调度算法，是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。 2. 先来先服务调度算法原理 先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。 三、程序设计 1.概要设计 程序包括主函数、FCFS算法函数、SJF算法函数、输出函数；主函数流程：输入文件中的数据—显示各进程数据—选择算法—调用相应算法的函数—输出结果 2.算法流程 SJF算法流程图： 3.详细设计 （1）定义一个结构体 typedef struct PCB { char job_id[10]; //作业ID float Arr_time; //到达时刻 float Fun_time; //估计运行时间 float Wait_time; //等待时间 float Start_time; //开始时刻 float Fin_time; //完成时刻 float Tur_time; //周转时间 float WTur_time; //带权周转时间 int Order; //优先标记 }list; （2）先来先服务算法函数 void fcfs(list *p,int count) //先来先服务算法{ list temp; //临时结构体变量int i; int j; 实验一进程调度 一、实验目的 编写并调试一个模拟的进程调度程序，以加深对进程的概念及进程调度算法的理解． 二、实验内容 1.采用“短进程优先”调度算法对五个进程进行调度。每个进程有一个进 程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、到达 时间、需要运行时间、已用CPU时间、进程状态等等。 2.每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish） 三种状态之一。每进行一次调度程序都打印一次运行进程、就绪队列、 以及各个进程的 PCB，以便进行检查。重复以上过程，直到所要进程都 完成为止。 三、实现思路 主函数-输入函数-短作业优先调度函数-输出函数。 这是一条最基础的思路。输入函数使用文本导入完成数据输入，输出函数输出调度结果，主函数完成各子函数连接，最主要的是短作业优先的调度函数。我想到的方法就是排序，不断选择需要运行时间最短的作业，接着进行数据输入计算输出等，遍历全部数据并完成调度。 四、主要的数据结构 struct Process_struct{ char name[MaxNum]; //进程名称 int arrivetime; //到达时间 int servertime; //开始运行时间 int finishtime; //运行结束时间 int runtime; //运行时间 int runflag; //调度标志 int order; //运行次序 double weightwholetime; //周转时间 double averagewt_FCFS,averagewt_SJF; //平均周转时间 double averagewwt_FCFS,averagewwt_SJF; //平均带权周转时间 }pro[MaxNum]; 五、算法流程图 六、运行与测试 用书上数据对程序进行测试，结果如下： 操作系统-先来先服务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个进程的平均周转时间和平均带权周转时间。 (4)测试用例 操作系统上机测试作业调度算法算法 一、实验目的和要求（供参考） 1.掌握作业调度功能和调度程序常用算法。 2.掌握利用C语言设计实现不同调度策略的作业调度算法。 3.验证不同作业调度算法对性能的影响。 二、实验环境（供参考） 1.知识准备：学过进程管理、作业管理、处理机调度等章节的内容。 2.开发环境与工具： 硬件平台——个人计算机。 软件平台——C语言开发环境。 三、实验内容 用“先来先服务（FCFS）”算法和“最短作业优先（SJF）”算法模拟作业调度。 要求：按作业的到达顺序输入各作业需要的运行时间，按算法调度输出平均周转时间。 例如(FCFS)，输入：8（到达时间0），5（到达时间2），7（到达时间3），1（到达时间6）J1 J2 J3 J4 0 8 13 20 21 输出：aver=(8+(13-2)+(20-3)+(21-6))/4=51/4 例如(SJF)，输入：8（到达时间0），5（到达时间2），7（到达时间3），1（到达时间6）J1 J4 J2 J3 0 8 9 14 21 输出：aver=(8+(9-6)+(14-2)+(21-3))/4=42/4 注：输入的格式任意，只要输出平均周转时间即可。 四、代码（带注释） 1、先来先服务 实验结果（截图呈现） 代码： #include 实验二作业调度 一.实验题目 1、编写并调试一个单道处理系统的作业等待模拟程序。 作业调度算法：分别采用先来先服务（FCFS），最短作业优先（SJF）、响应比高者优先（HRN）的调度算法。 （1）先来先服务算法：按照作业提交给系统的先后顺序来挑选作业，先提交的先被挑选。 （2）最短作业优先算法：是以进入系统的作业所提出的“执行时间”为标准，总是优先选取执行时间最短的作业。 （3）响应比高者优先算法：是在每次调度前都要计算所有被选作业（在后备队列中）的响应比，然后选择响应比最高的作业执行。 2、编写并调度一个多道程序系统的作业调度模拟程序。 作业调度算法：采用基于先来先服务的调度算法。可以参考课本中的方法进行设计。 对于多道程序系统，要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。 二.实验目的： 本实验要求用高级语言（C语言实验环境）编写和调试一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解 三 .实验过程 <一>单道处理系统作业调度 1)单道处理程序作业调度实验的源程序: 执行程序: 2)实验分析： 1、由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的 CPU 时限等因素。 2、每个作业由一个作业控制块JCB 表示，JCB 可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。每个作业的最初状态总是等待W 。 3、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间。 3)流程图: 二.最短作业优先算法 三.高响应比算法 图一.先来先服务流程图 4)源程序: #include <> #include <> #include <> #define getpch(type) (type*)malloc(sizeof(type)) #define NULL 0 int n; 代替 代替 O S短作业优先调度算 法C语言 采用短作业优先调度算法调度程序 学号： 姓名： 专业： 指导老师： 日期： 目录 一、实验题目 (3) 二、课程设计的目的 (3) 三、设计内容 (3) 四、设计要求 (3) 五、主要数据结构及其说明 (4) 六、程序运行结果 (5) 七、流程图 (7) 八、源程序文件 (9) 九、实验体会 (13) 十、参考文献 (14) 摘要 在多道程序环境下，主存中有着多个进程，其数目往往多于处理机数目。这就要求系统能按某种算法，动态地把处理机分配给就绪队列中的一个进程，使之执行。分配处理机的任务是由处理机调度程序完成的。由于处理机是最重要的计算机资源，提高处理机的利用率及改善系统性能（吞吐量、响应时间），在很大程度上取决于处理机调度性能的好坏，因而，处理机调度便成为操作系统设计的中心问题之一。 在多道程序系统中，一个作业被提交后必须经过处理机调度后，方能获得处理机执行。对于批量型作业而言，通常需要经历作业调度和进程调度两个过程后方能获得处理机。作业调度是对成批进入系统的用户作业，根据作业控制块的信息，按一定的策略选取若干个作业使它们可以去获得处理器运行的一项工作。而对每个用户来说总希望自己的作业的周转时间是最小的，短作业优先（SJF）便是其中一种调度方法。本次课程设计主要是模拟短作业优先(SJF)调度算法。 一、实验题目 采用短作业优先算法的的进程调度程序 二、课程设计的目的 ●操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既 动手又动脑，将课本上的理论知识和实际有机的结合一起，独立分析和解决实际问题的机会。 ●进一步巩固和复习操作系统的基础知识。 ●培养学生结构化程序、模块化程序设计的方法和能力。 ●提高学生调试程序的技巧和软件设计的能力。 ●提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。 三、设计内容 设计并实现一个采用短作业优先算的进程调度算法演示程序 四、设计要求 1. 每一个进程有一个PCB，其内容可以根据具体情况设定。 2. 进程数、进入内存时间、要求服务时间、优先级等均可以在界面上设定 课程设计报告课程设计题目：短作业优先(SJF)调度算法模拟 专业：计算机科学与技术 班级： 姓名： 学号: 指导教师: 2013年01 月09日 目录 摘要 (2) 第一章概述 (3) 1.1 课程设计的目的 (3) 1.2 主要完成的任务 (3) 1.3 使用的开发工具 (3) 1.4解决的主要问题 (3) 第二章课程设计的基本概念和原理 (4) 第三章总体设计 (5) 第四章详细设计 (6) 4.1数据结构 (6) 4.2具体数据结构和模块设计简要说明 (6) 4.3 程序相关数据 (6) 第五章短作业优先调度的算法实现 (9) 第六章设计结果及分析 (16) 总结 (20) 参考文献 (21) 评分表 (22) 摘要 在多道程序环境下，主存中有着多个进程，其数目往往多于处理机数目。这就要求系统能按某种算法，动态地把处理机分配给就绪队列中的一个进程，使之执行。分配处理机的任务是由处理机调度程序完成的。由于处理机是最重要的计算机资源，提高处理机的利用率及改善系统性能（吞吐量、响应时间），在很大程度上取决于处理机调度性能的好坏，因而，处理机调度便成为操作系统设计的中心问题之一。 在多道程序系统中，一个作业被提交后必须经过处理机调度后，方能获得处理机执行。对于批量型作业而言，通常需要经历作业调度和进程调度两个过程后方能获得处理机。作业调度是对成批进入系统的用户作业，根据作业控制块的信息，按一定的策略选取若干个作业使它们可以去获得处理器运行的一项工作。而对每个用户来说总希望自己的作业的周转时间是最小的，短作业优先（SJF）便是其中一种调度方法。 本次课程设计主要是模拟短作业优先(SJF)调度算法。 关键字：多道程序进程调度短作业优先(SJF)调度算法 实验二作业调度实验 一. 目的要求： 用高级语言编写和调试一个或多个作业调度的模拟程序，以加深对作业调度算法的理解。 二. 例题：为单道批处理系统设计一个作业调度程序。 由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的 CPU时限等因素。 作业调度算法：采用先来先服务（FCFS）调度算法，即按作业提交的先后次序进行调度。总是首先调度在系统中等待时间最长的作业。 每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。 作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。每个作业的最初状态总是等待W。 各个等待的作业按照提交时刻的先后次序排队，总是首先调度等待队列中队首的作业。 每个作业完成后要打印该作业的开始运行时刻、完成时刻、周转时间和带权周转时间，这一组作业完成后要计算并打印这组作业的平均周转时间、带权平均周转时间。 调度算法的流程图如下图所示。 三 . 实习题： 1、编写并调试一个单道处理系统的作业等待模拟程序。 作业等待算法：分别采用先来先服务（FCFS），最短作业优先（SJF）、响应比高者优先（HRN）的调度算法。 对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间，以比较各种算法的优缺点。 2、编写并调度一个多道程序系统的作业调度模拟程序。 作业调度算法：采用基于先来先服务的调度算法。可以参考课本中的方法进行设计。 对于多道程序系统，要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。 3、编写并调试一个多道程序系统的作业调度模拟程序。 作业调度算法：采用基于优先级的作业调度。 可以参考课本中的例子自行设计。 三 . 实验过程： 1、编写并调试一个单道处理系统的作业等待模拟程序。 先来先服务（FCFS）： main.cpp: /* **先来先服作业调度算法模拟 */ #include 《操作系统》课程实验报告实验名称：短作业优先调度算法 姓名：陈凯 学号：541413430202 地点：四教楼301 指导老师：张旭 专业班级：嵌入式软件14-02 一、实验目的： 测试数据可以随即输入或从文件中读入。 必须要考虑到作业的到达时间 最终能够计算每一个作业的周转时间。 二、实验内容： 模拟实现短作业调度算法，具体如下： 设置作业体：作业名，作业的到达时间，服务时间，作业间的链接指针 进程初始化：由用户输入作业名、作业的到达时间和服务时间进行初始化。 显示函数：1、显示当前调度的是哪个作业，后备队列中有哪些作业 2、最终显示每个作业的作业名、到达时间、服务时间、完成时间和周转时间 排序函数：对就已到达的作业按照服务时间进行排序。注意考虑到达时间 调度函数：每次从已到达的作业队列队首调度优一个作业执行。 删除函数：作业结束后撤销。 三、实验代码 #include #include 操作系统实验-FCFS和短作业优先SJF调度算法模拟
短作业优先算法
短作业优先调度算法 (1)
操作系统实验 FCFS和短作业优先SJF调度算法模拟
短作业优先调度
操作系统-先来先服务FCFS和短作业优先SJF进程
操作系统作业调度算法
作业调度实验报告
OS短作业优先调度算法C语言知识分享
短作业优先调度算法
各类作业调度算法
短作业优先调度算法
短作业优先调度算法C语言实现
相关主题
文本预览