进程调度算法的实现
第5部分、进程调度算法的实现：
●基本要求：在1、2、3阶段实验基础上实现按先来先服务FCFS、短作业优先SJF以及时间片轮转算法调度进程的模拟过程。
●参考学时：8学时
●实验提示：
1、程序开始运行时选择调度算法，创建进程时输入进程所需服务时间以及
到达时间。
2、根据当前所设定调度算法，连续调度所有进程，并计算每个进程的周转
时间和带权周转时间、所有进程的平均周转时间和平均带权周转时间。
3、调度时应适当输出调度过程中各进程状态队列的变化情况以及进程的已
执行时间、还需服务时间（针对时间片轮转算法）。
//package osDe;
import java.util.V ector;
import java.io.*;
class Process{
String name;
int ArriveTime;
int ServeTime;
int startWorking;
int []finish=new int[3];
int []working=new int [3];
double poweringWorking;
int worktime;
int moreServeTime;
int id;
public void setArriveTime(int ArriveTime) {
this.ArriveTime=ArriveTime;
}
public int getArriveTime() {
return ArriveTime;
}
public void setServeTime(int ServeTime) {
this.ServeTime=ServeTime;
}
public int getServeTime() {
return ServeTime;
}
public String getName() {
return name;
}
Process(String name){
https://www.wendangku.net/doc/683765456.html,=name;
}
Process(String name,int ArriveTime,int ServeTime,int id) {
https://www.wendangku.net/doc/683765456.html,=name;
this.ArriveTime=ArriveTime;
this.ServeTime=ServeTime;
this.id=id;
this.moreServeTime=ServeTime;
}
public String toString(){
return name;
}
}
public class OS1 {
public static V ector
public static Process running;
public static BufferedReader br;
public static V ector
public static int count=0;
public OS1() {
ready=new V ector
blocked=new V ector
br=new BufferedReader(new InputStreamReader(System.in));
p=new V ector
init();
}
public static void go() {
while(true){
System.out.println("==================================================== ===================");
System.out.println("1:进程创建");
System.out.println("2:进程到时");
System.out.println("3:进程阻塞");
System.out.println("4:进程唤醒");
System.out.println("5:进程结束");
// System.out.println("6:选择调度算法(1 FCFS 2 SJF 3 RR)");
System.out.println("6:按先来先服务调度");
System.out.println("7:按短作业优先调度");
System.out.println("8:按时间片调度");
//System.out.println("7:显示进程调度结果");
System.out.println("0:退出-->");
try{
int i=Integer.parseInt(br.readLine());
switch(i){
case 0:
System.exit(0);
case 1:
createNewProcess();
break;
case 2:
switchCurrentProcess();
break;
case 3:
blockCurrentProcess();
break;
case 4:
wakeupBlockedProcess();
break;
case 5:
terminateCurrentProcess();
break;
case 6:
FCFS(p);
break;
case 7:
SJF(p);
break;
case 8:
RR(p);
break;
}
}
catch(Exception e){
System.out.println(e);
}
//
// System.out.println("执行进程:"+(running==null?"none":running)); // System.out.print("就绪进程:");
// printList(ready);
// System.out.print("阻塞进程:");
// printList(blocked);
}
}
public static void printList(V ector v){
for(int i=0;i System.out.print(v.elementAt(i)+"\t"); System.out.println(); } public static void createNewProcess(){ try{ System.out.print("进程名称:"); String name=br.readLine(); //Process process=new Process(name); // ready.add(new Process(name)); System.out.print("进程到达时间:"); int ArriveTime=Integer.parseInt(br.readLine()); //process.setArriveTime(ArriveTime); System.out.print("进程服务时间:"); int ServeTime=Integer.parseInt(br.readLine()); //process.setServeTime(ServeTime); Process process=new Process(name,ArriveTime,ServeTime,++count); ready.add(process); p.add(process); if(running==null){ running=(Process)ready.elementAt(0); ready.removeElementAt(0); } } catch(Exception e){ System.out.println(e); } } public static void switchCurrentProcess(){ if(running!=null) ready.add(running); if(ready.size()>0){ running=(Process)ready.elementAt(0); ready.removeElementAt(0); } else running=null; } public static void blockCurrentProcess(){ if(running!=null) { blocked.add(running); } if(ready.size()>0) { running=(Process)ready.elementAt(0); ready.removeElementAt(0); } else { running=null; } } public static void wakeupBlockedProcess() { if(blocked.size()>0){ //running=(Process)blocked.elementAt(0); ready.add((Process)blocked.elementAt(0)); blocked.removeElementAt(0); if(running==null) { running=(Process)ready.elementAt(0); ready.removeElementAt(0); } } else { //blocked=null; } } public static void terminateCurrentProcess() { if(running!=null) { running=null; } if(ready.size()>0) { running=(Process)ready.elementAt(0); ready.removeElementAt(0); } else if(blocked.size()>0){ running=(Process)blocked.elementAt(0); blocked.removeElementAt(0); } else { running=null; } } public static void init() { Process p1=new Process("A",0,4,count++); Process p2=new Process("B",1,3,count++); Process p3=new Process("C",2,5,count++); Process p4=new Process("D",3,2,count++); Process p5=new Process("E",4,4,count++); // Process p1=new Process("A",0,1); // Process p2=new Process("B",1,100); // Process p3=new Process("C",2,1); // Process p4=new Process("D",3,100); //Process p5=new Process("E",4,4); p.add(p1); p.add(p2); p.add(p3); p.add(p4); p.add(p5); ready.add(p1); ready.add(p2); ready.add(p3); ready.add(p4); ready.add(p5); if(running==null){ running=(Process)ready.elementAt(0); ready.removeElementAt(0); } } public static void FCFS(V ector showFCFSProcess(); double averoundTime=0; double aveweightroundTime=0; if(p1.elementAt(0)!=null) { p1.elementAt(0).startWorking=p1.elementAt(0).ArriveTime; } for(int i=0;i if(p1.elementAt(i)!=null) { p1.elementAt(i).finish[0]= p1.elementAt(i).startWorking+p1.elementAt(i).ServeTime; p1.elementAt(i).working[0]=p1.elementAt(i).finish[0]-p1.elementAt(i).ArriveTime; p1.elementAt(i).poweringWorking=p1.elementAt(i).working[0]/(double)p1.elementAt(i).Ser veTime; int b=i; ++b; //System.out.println("b="+b); if(b int Temp=p1.elementAt(i).finish[0]; ++i; // System.out.println("i="+i); if(Temp p1.elementAt(i).startWorking=p1.elementAt(i).ArriveTime; } else { p1.elementAt(i).startWorking=Temp; } } else { ++i; } } else { break; } } System.out.println("进程名"+"\t"+"到达时间"+"\t"+"服务时间"+"\t"+"开始执行时间"+ "\t"+"完成时间"+"\t"+"周转时间"+"\t"+"带权周转时间"); for(int i=0;i if(p1.elementAt(i)!=null) { System.out.println(p1.elementAt(i).getName()+"\t"+p1.elementAt(i).ArriveTime+"\t"+p1.ele mentAt(i).ServeTime+"\t"+ p1.elementAt(i).startWorking+"\t"+p1.elementAt(i).finish[0]+"\t"+p1.elementAt(i).working[ 0]+"\t"+p1.elementAt(i).poweringWorking); averoundTime+=p1.elementAt(i).working[0]; aveweightroundTime+=p1.elementAt(i).poweringWorking; } else { break; } } System.out.println("平均周转时间"+averoundTime/(float)p1.size()+" "+"平均带权周转时间"+aveweightroundTime/(float)p1.size()); } public static void SJF(V ector showSJFProces(); double averoundTime=0; double aveweightroundTime=0; int minServiceTime=0; int index=0; int preFinish=0; if(p1.size()>0) { p1.elementAt(0).startWorking=p1.elementAt(0).ArriveTime; p1.elementAt(0).finish[1]= p1.elementAt(0).startWorking+p1.elementAt(0).ServeTime; p1.elementAt(0).working[1]=p1.elementAt(0).finish[1]-p1.elementAt(0).ArriveTime; p1.elementAt(0).poweringWorking=p1.elementAt(0).working[1]/(double)p1.elementAt(0).ServeT ime; preFinish=p1.elementAt(0).finish[1]; } for(int i=1;i minServiceTime=1000; for(int j=1;j if(minServiceTime>p1.elementAt(j).ServeTime&&p1.elementAt(j).finish[1]==0&&preFinis h>=p1.elementAt(j).ArriveTime) { minServiceTime=p1.elementAt(j).ServeTime; index=j; } } if(p1.elementAt(index).ArriveTime<=preFinish) { p1.elementAt(index).startWorking=preFinish; } else { p1.elementAt(index).startWorking=p1.elementAt(index).ArriveTime; } p1.elementAt(index).finish[1]= p1.elementAt(index).startWorking+p1.elementAt(index).ServeTime; p1.elementAt(index).working[1]=p1.elementAt(index).finish[1]-p1.elementAt(index).ArriveTime; p1.elementAt(index).poweringWorking=p1.elementAt(index).working[1]/(double)p1.elementAt(i ndex).ServeTime; preFinish=p1.elementAt(index).finish[1]; } System.out.println("进程名"+"\t"+"到达时间"+"\t" +"服务时间"+"\t"+"开始执行时间"+ "\t"+"完成时间"+"\t"+"周转时间"+"\t"+"带权周转时间"); for(int i=0;i if(p1.elementAt(i)!=null) { System.out.println(p1.elementAt(i).getName()+"\t"+p1.elementAt(i).ArriveTime+"\t"+p1.ele mentAt(i).ServeTime+"\t"+ p1.elementAt(i).startWorking+"\t"+p1.elementAt(i).finish[1]+"\t"+p1.elementAt(i).working[ 1]+"\t"+p1.elementAt(i).poweringWorking); averoundTime+=p1.elementAt(i).working[1]; aveweightroundTime+=p1.elementAt(i).poweringWorking; } else { break; } } System.out.println("平均周转时间"+averoundTime/(float)p1.size()+" "+"平均带权周转时间"+aveweightroundTime/(float)p1.size()); } public static void RR(V ector int finishTime=0; double averoundTime=0; double aveweightroundTime=0; try { int q=0; System.out.print("请输入时间片大小:"); q=Integer.parseInt(br.readLine()); if(q<=0) { System.out.println("输入不合法"); return; } showRRProcess(q,p1); for(int j=0;j p1.elementAt(j).working[2]=p1.elementAt(j).finish[2]-p1.elementAt(j).ArriveTime; p1.elementAt(j).poweringWorking=p1.elementAt(j).working[2]/(double)p1.elementAt(j).Ser veTime; } System.out.println("进程名"+"\t"+"到达时间"+"\t" +"服务时间"+ "\t"+"完成时间"+"\t"+"周转时间"+"\t"+"带权周转时间"); for(int i=0;i if(p1.elementAt(i)!=null) { System.out.println(p1.elementAt(i).getName()+"\t"+p1.elementAt(i).ArriveTime+"\t"+p1.ele mentAt(i).ServeTime +"\t"+p1.elementAt(i).finish[2]+"\t"+p1.elementAt(i).working[2]+"\t"+p1.elementAt(i).powe ringWorking); averoundTime+=p1.elementAt(i).working[2]; aveweightroundTime+=p1.elementAt(i).poweringWorking; } else { break; } } System.out.println("平均周转时间"+averoundTime/(float)p1.size()+" "+"平均带权周转时间"+aveweightroundTime/(float)p1.size()); }catch(Exception e) { System.out.println(e); } } public static void showFCFSProcess() { int i=0; while(true) { if(running!=null) { if(i!=running.ServeTime) { System.out.println("执行进程:"+running); System.out.println("到达时间:"+running.ArriveTime+","+"服务时间:" +running.ServeTime+","+"执行时间:"+(++i)); System.out.println("就绪进程:"); for(int j=0;j System.out.println(ready.elementAt(j)+","+"到达时间:"+ready.elementAt(j).ArriveTime+ ","+"服务时间:"+ready.elementAt(j).ServeTime+","+"执行时间:"+0); } System.out.println("阻塞进程:"); printList(blocked); } else { terminateCurrentProcess(); i=0; } } else { System.out.println("执行进程:"+"none"); System.out.println("执行进程:"); System.out.println("阻塞进程:"); return; } } } public static void showSJFProces() { int i=0; while(true) { if(running!=null) { if(i!=running.ServeTime) { System.out.println("执行进程:"+running); System.out.println("到达时间:"+running.ArriveTime+","+"服务时间:" +running.ServeTime+","+"执行时间:"+(++i)); System.out.println("就绪进程:"); for(int j=0;j System.out.println(ready.elementAt(j)+","+"到达时间:"+ready.elementAt(j).ArriveTime+ ","+"服务时间:"+ready.elementAt(j).ServeTime+","+"执行时间:"+0); } System.out.println("阻塞进程:"); printList(blocked); } else { terminateCurrentProcess(); int index=findServeTime(); System.out.println("index="+index); for(int j=0;j switchCurrentProcess(); } i=0; } } else { System.out.println("执行进程:"+"none"); System.out.println("执行进程:"); System.out.println("阻塞进程:"); return; } } } public static int findServeTime() { int index=0; int minServeTime=0; if(ready.size()>0) { minServeTime=ready.elementAt(0).ServeTime; } for(int j=1;j if(ready.elementAt(j).ServeTime //System.out.println("minServeTime="+minServeTime); //System.out.println("ready.elementAt(j).ServeTime="+ready.elementAt(j).ServeTime); minServeTime=ready.elementAt(j).ServeTime; index=j; } } return index; } public static void showRRProcess(int q,V ector int i=0; while(true) { if(running!=null) { if(running.worktime!=q) { if(running.worktime!=running.ServeTime&&running.moreServeTime>0) { ++i; ++running.worktime; System.out.println("执行进程:"+running); System.out.println("到达时间:"+running.ArriveTime+","+"服务时间:"+running.ServeTime+"," +"还需服务时间:"+(--running.moreServeTime)+"执行时间:"+(running.ServeTime-running.moreServeTime)); System.out.println("就绪进程:"); for(int j=0;j System.out.println(ready.elementAt(j)+","+"到达时间:"+ready.elementAt(j).ArriveTime+ ","+"服务时间:"+ready.elementAt(j).ServeTime+","+"执行时间:"+0); } System.out.println("阻塞进程:"); printList(blocked); } else { // running.finish[2]= p1.elementAt(running.id).finish[2]=i; terminateCurrentProcess(); } } else { if(running.moreServeTime!=0) { running.worktime=0; switchCurrentProcess(); } else { // System.out.println("heloffffff"); p1.elementAt(running.id).finish[2]=i; // System.out.println("p1.elementAt(running.id).finish[2]="+p1.elementAt(running.id).finish[2] ); terminateCurrentProcess(); } } } else { System.out.println("执行进程:"+"none"); System.out.println("执行进程:"); System.out.println("阻塞进程:"); return; } } } public static void main(String[]args) { new OS1().go(); } } 《操作系统原理》实验报告 实验名称：Linux随机进程调度算法实现 班级： 学号： 姓名： 日期： 2012/12/31 一、实验名称 Linux随机进程调度算法实现 二、所属课程名称 《操作系统原理》 三、实验原理 linux 0.11内核目录linux/kernel中的sched.c函数是内核中进程调度管理的程序，其中schedule()函数负责选择系统中下一个要运行的进程。 schedule()函数首先对所有任务（进程）进行检测，唤醒任何一个已经得到信号的进程。具体方法是任务数组中的每个进程，检查其报警定时值alarm。如果进程的alarm时间已经过期（alarm NR_TASKS：系统能容纳的最大进程数(64个)； task[]：任务（进程）数组； 更改代码如下：（linux 0.11内核目录下linux/kernel/sched.c 源文件的scheduling（）函数while（1）循环）while (1) { //定义c用来判断系统中是否可运行的任务（进程）存在; c=-1; //c初值设为-1，默认不存在可运行进程; next = 0;//next记录下一个即将运行的进程; i=jiffies % NR_TASKS+1; //i的值是随机产生的; p=&task[i];//p指向在task表中下标为i的进程； while (--i) { //遍历task[]； if(!*--p)continue; //如果task[i]不包含进程，跳过； //如果task[i]包含进程且该进程处于就绪状态，记录 //该任务（进程）序号，跳出无限循环while(1),转向 //switch_to()函数执行该任务（进程）； if ((*p)->state == TASK_RUNNING) { next = i; c=i; break; } } if (c) break;//如果没有任何任务(进程)要执行，则跳出， //转向switch_to()，执行0号进程(idle)。 } 进程调度算法实验报告 篇一：操作系统进程调度算法模拟实验报告 进程调度算法模拟 专业：XXXXX 学号：XXXXX 姓名：XXX 实验日期：20XX年XX月XX日 一、实验目的 通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。 二、实验要求 编写程序实现对5个进程的调度模拟，要求至少采用两种不同的调度算 法分别进行模拟调度。 三、实验方法内容 1. 算法设计思路 将每个进程抽象成一个控制块PCB， PCB用一个结构体描述。 构建一个进程调度类。将进程调度的各种算法分装在一个类中。类中存 在三个容器，一个保存正在或未进入就绪队列的进程，一个保存就绪的进程，另一个保存已完成的进程。还有一个PCB实例。主要保存正在运行的进程。类中其他方法都是围绕这三个容器可以这个运行中的PCB展开。 主要用到的技术是STL中的vector以维护和保存进程容器、就绪容器、 完成容器。 当程序启动时，用户可以选择不同的调度算法。然后用户从控制台输入 各个进程的信息，这些信息保存到进程容器中。进程信息输入完毕后，就开始了进程调度，每调度一次判断就绪队列是否为空，若为空则系统时间加一个时间片。判断进程容器中是否有新的进程可以加入就绪队列。 2. 算法流程图主程序的框架： ();//先来先服务 ();//最短进程优先调度//简单时间片轮转//最高优先数优先//输入进程信息 ();.m_WaitQueue.empty()||.m_ProcessQueue.empt() (); (); 进程调度过程： ; 3. 算法中用到的数据结构 struct fcfs{//先来先服务算法从这里开始char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;float 福建农林大学计算机与信息学院 课程设计报告 课程名称：操作系统 实习题目：进程调度算法模拟 姓名： 系：计算机科学与技术系 专业：计算机科学与技术 年级：2012 学号： 指导教师： 职称：副教授 年月日 福建农林大学计算机与信息学院计算机类 课程设计结果评定 目录 1.本选题课程设计的目的 (4) 2.本选题课程设计的要求 (4) 3.本选题课程设计报告内容 (4) 3．1前言 (4) 3．2进程调度算法模拟的环境 (4) 3．3系统技术分析 (4) 3．4系统流程图及各模块 (5) 3．5程序调试情况 (8) 4．总结 (11) 参考文献 (11) 程序代码 (12) 1.设计目的 课程设计将课本上的理论知识和实际有机的结合起来，锻炼学生的分析系统，解决实际问题的能力。提高学生分析系统、实践编程的能力。 2.设计要求 利用学到的操作系统和编程知识，完成具有一定难度的系统分析研究或系统设计题目。其中：专题系统理论研究应包括研究目的、目标，论点和论据以及证明推导等；分析、设计系统应包括编写、调试程序以及最后写出设计报告或系统说明文档文件，系统说明文档包括系统界面、变量说明、系统功能说明、编程算法或思路、流程图和完整程序。具体要求如下： 1、对系统进行功能模块分析、控制模块分析正确； 2、系统设计要实用； 3、编程简练，可用，功能全面； 4、说明书、流程图要清楚。 3.设计方案 3.1前言 本程序包括三种算法，用C或C++语言实现，执行时在主界面选择算法（可用函数实现），进入子页面后输入进程数，（运行时间，优先数由随机函数产生），执行，显示结果。 3.2本选题设计的环境 WindowsXP下的Microsoft Visual C++ 6.0 3.3系统技术分析 （1）编程实现对N个进程采用某种进程调度算法（如动态优先权调度算法、先来先服务算法、短进程优先算法、时间片轮转调度算法）调度执行的模拟。（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：进程标识数ID。 进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。 作业调度 一、实验名称 作业调度算法 二、实验目标 在单道环境下编写作业调度的模拟程序，以加深对作业调度的理解。单道环境的特点使被调度的作业占有所有的资源。实现的算法有先来先服务，最短作业优先，最高响应比三种作业调度算法。 三、实验环境要求： 1.PC机。 2.Windows； 3.CodeBlocks 四、实验基本原理 1.本实验设计一个可指定作业个数的作业调度系统。可以输出先来先服务，最短作业优先，最高响应比三种作业调度算法的结果。 2.先来先服务就是按照各个作业进入系统的自然次序进行调度。最短作业优先就是优先调度并且处理短作业。最高响应比优先就是根据在程序运行过程中的最高响应比对应的作业先进行调度处理。 3.在设计程序过程中，将time相关的内容封装到类中，重载了加减乘除和输入输出以及比较运算符，方便12:00这种形式的数据的加减乘除运算和比较运算， 五、数据结构设计 1.时间类 class time { public: time(int x = 0, int y = 0) { time::hour = x; time::minute = y; } time& operator = (const time &t1) { this->hour=t1.hour; this->minute=t1.minute; return *this; } time operator + (time t2) { intminutes,hours; minutes = (minute + t2.minute) % 60; hours=hour+t2.hour+ (minute + t2.minute) /60; return time(hours,minutes); } time operator -(time t2) { intminutes,hours; minutes =minute - t2.minute; if (minute<0) { minutes += 60; hour--; } 实验一模拟实现进程调度算法(4学时) ①、实验目的 a、进程调度是处理机管理的核心内容。观察、体会操作系统的进程调度方法，并通过一个简单的进程调度模拟程序的实现，加深对进程控制块、进程队列、进程调度算法，进程切换的理解，并体会和了解各种调度算法的具体实施办法。 b、提高实际动手编程能力，为日后从事软件开发工作打下坚实基础。 ②、实验内容 a、设计进程控制块PCB表结构，模拟实现进程调度算法：FIFO，静态优先级调度，时间片轮转调度，短进程优先调度算法，多级反馈队列调度。（实现静态优先级调度算法、短进程优先调度算法）。 b、编写一个进程调度程序模拟程序。模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。 c、由用户输入（可通过文件输入）进程名、进程状态、进程运行时间和进程优先级等数据。 ③、实验要求 a、使用模块化设计思想来设计。 b、给出主函数和各个算法函数的流程图。 c、学生可按照自身条件，随意选择采用的算法，（例如：采用冒泡法编写程序，实现短进程优先调度的算法）。 d、进程调度程序模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。 ④、运行结果 a、给出进程的调度模拟操作排序结果。 ⑤、提示 a、每个进程可有三个状态，并假设初始状态为就绪状态。 b、为了便于处理，程序中的进程运行时间以纳秒为单位计算。 C、各进程的优先级或轮转时间数以及进程需运行的纳秒数的初始值均由用户给定。 d、在优先级算法中，采用静态优先级。在时间片轮转算法中，采用可变时间片，由用户给定。 e、对于遇到优先级一致的情况，采用FIFO策略解决。 f、输入：进程流文件（文本文件），其中存储的是一系列要执行的进程，每个进程包括四个数据项：进程名进程状态(1就绪2等待3运行) 所需时间优先级(0级最高)。 g、输出：进程执行流等待时间平均等待时间。 ⑥、分析与讨论 a、各种进程调度算法的异同？ b、如何理解“算法+数据结构=程序设计”？ c、如何理解“数据结构始终是为实现功能服务的”？ ⑦、参考代码 参看：附录A1 考核方法： 1、实验报告占50%，程序设计30%，出勤占20%； 3、每次实验100分，2次实验的平均分为最终实验成绩。 注：无出勤只交实验报告者，以实验报告成绩×50%为最后成绩。 打游戏者发现一次本次实验扣10分。 早退者本次实验扣10分。 点名时未到者，后来补签到按照迟到时间长短扣分，点名后即来扣5分，1节课过后才来扣10分。 华北科技学院计算机系综合性实验 实验报告 课程名称操作系统C 实验学期2012至2013学年第2学期学生所在系部计算机系 年级专业班级 学生姓名学号 任课教师杜杏菁 实验成绩 计算机系制 《操作系统C》课程综合性实验报告 开课实验室：基础六机房2013年6月3日 实验题目进程调度算法模拟 一、实验目的 通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。 二、设备与环境 1.硬件设备：PC机一台 2.软件环境：安装Windows操作系统或者Linux操作系统，并安装相关的程序开发环境，如C \C++\Java等编程语言环境。 三、实验内容 （1）用C语言（或其它语言，如Java）实现对N个进程采用某种进程调度算法（如动态优先权调度）的调度。 （2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段： ?进程标识数ID。 ?进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。 ?进程已占用CPU时间CPUTIME。 ?进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。 ?进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进 入阻塞状态。 ?进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将 转换成就绪状态。 ?进程状态STATE。 ?队列指针NEXT，用来将PCB排成队列。 （3）优先数改变的原则： ?进程在就绪队列中呆一个时间片，优先数增加1。 ?进程每运行一个时间片，优先数减3。 （4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。 操作系统实验报告（二） 实验题目：进程调度算法 实验环境：C++ 实验目的：编程模拟实现几种常见的进程调度算法，通过对几组进程分别使用不同的调度算法，计算进程的平均周转时间和平均带权周转时间，比较 各种算法的性能优劣。 实验内容：编程实现如下算法： 1.先来先服务算法； 2.短进程优先算法； 3.时间片轮转调度算法。 设计分析： 程序流程图： 1.先来先服务算法 开始 初始化PCB，输入进程信息 各进程按先来先到的顺序进入就绪队列 结束 就绪队列？ 运行 运行进程所需CPU时间 取消该进程 2.短进程优先算法 3.时间片轮转调度算法 实验代码： 1.先来先服务算法 #include int atime; //进程到达时间 int runtime; //进程运行时间 }fcs; void main() { int amount,i,j,diao,huan; fcs f[n]; cout<<"请输入进程个数:"< 操作系统课程设计报告题目：进程调度算法的模拟实现_ 专业计算机科学与技术 学生姓名 班级 学号 指导教师 发放日期2015.1.30 信息工程学院 目录 1 概述 (1) 2 设计原理 (1) 2.1先来先服务算法 (1) 3 详细设计与编码 (2) 3.1 模块设计 (2) 3.2 系统流程图 (2) 3.3 系统详细设计 (2) 4 结果与分析 (6) 4.1 测试方案 (6) 4.2 测试结果 (6) 4.3 测试结果分析 (9) 5 设计小结 (10) 6 参考文献 (10) 附录程序代码 (12) 进程调度算法的模拟实现 进程调度算法的模拟实现 1 概述 选择一个调度算法，实现处理机调度，进程调度算法包括：先来先服务算法，短进程优先算法，时间片轮转算法，动态优先级算法。可选择进程数量，本程序包括四种算法，用C或C++语言实现，执行时在主界面选择算法（可用函数实现），进入子页面后输入进程数，（运行时间，优先数由随机函数产生），执行，显示结果。 2 设计原理 2.1先来先服务(FCFS)算法 每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源创建进程，然后放入就绪队列 2.2 时间片轮转法(RR)算法 系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。时间片的大小从几ms到几百ms。当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。 2.3短作业优先(SJF)算法 短作业优先调度算法是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。 2.4最高优先权优先(HRRN)算法 优先权调度算法是为了照顾紧迫型作业，使之在进入系统后便获得优先处理，引入最高优先权优先调度算法。动态优先权是指在创建进程时所赋予的优先权，是可以随进程的推进或随其等待时间的增加而改变的，以便获得更好的调度性能。 一．课程概述 1.1.设计构想 程序能够完成以下操作：创建进程：先输入进程的数目，再一次输入每个进程的进程名、运行总时间和优先级，先到达的先输入；进程调度：进程创建完成后就选择进程调度算法，并单步执行，每次执行的结果都从屏幕上输出来。 1.2.需求分析 在多道程序环境下，主存中有着多个进程，其数目往往多于处理机数目，要使这多个进程能够并发地执行，这就要求系统能按某种算法，动态地把处理机分配给就绪队列中的一个进程，使之执行。分配处理机的任务是由处理机调度程序完成的。由于处理机是最重要的计算机资源，提高处理机的利用率及改善系统必（吞吐量、响应时间），在很大程度上取决于处理机调度性能的好坏，因而，处理机调度便成为操作系统设计的中心问题之一。本次实验在VC++6.0环境下实现先来先服务调度算法，短作业优先调度算法，高优先权调度算法，时间片轮转调度算法和多级反馈队列调度算法。 1.3.理论依据 为了描述和管制进程的运行，系统为每个进程定义了一个数据结构——进程控制块PCB(Process Control Block),PCB中记录了操作系统所需的、用于描述进程的当前情况以及控制进程运行的全部信息，系统总是通过PCB对进程进行控制，亦即，系统是根据进程的PCB 而不是任何别的什么而感知进程的存在的，PCB是进程存在的惟一标志。本次课程设计用结构体Process代替PCB的功能。 1.4.课程任务 一、用C语言（或C++）编程实现操作模拟操作系统进程调度子系统的基本功能；运用多 种算法实现对进程的模拟调度。 二、通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转、短作业优先、多 级反馈队列调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。 三、实现用户界面的开发 进程调度算法（附录）#include void display(pcb *p) { cout<<"name"<<" "<<"cputime"<<" "<<"needtime"<<" "<<"priority"<<" "<<"state"< （1）用C语言（或其它语言，如Java）实现对N个进程采用某种进程调度算法（如动态优先权调度）的调度。 （2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：?进程标识数ID。 ?进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。 ?进程已占用CPU时间CPUTIME。 ?进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。 ?进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间 片后，进程将进入阻塞状态。 ?进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME 个时间片后，将转换成就绪状态。 ?进程状态STATE。 ?队列指针NEXT，用来将PCB排成队列。 （3）优先数改变的原则： ?进程在就绪队列中呆一个时间片，优先数增加1。 ?进程每运行一个时间片，优先数减3。 （4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。 （5）分析程序运行的结果，谈一下自己的认识。 实验代码 #include "iostream.h" #include "windows.h" //#define N 3 typedef struct{ int ID; int PRIORITY; int CPUTIME; int ALLTIME; int STARTBLOCK; int BLOCKTIME; int STATE;//0-运行1-阻塞2-就绪3-结束4-未到达 int REACH; int TIME; }PROCESS; void textcolor (int color) { SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color ); } void main(){ int i,time,max,l,l1,time1,flag=0,total=0,N,server[10],sum=0; PROCESS pro[10]; textcolor(13); cout<<"注意：本程序中状态代表如下"< 操作系统 ——项目文档报告 进程调度算法 专业： 班级： 指导教师： 姓名： 学号： 一、核心算法思想 1.先来先服务调度算法 先来先服务调度算法是一种最简单的调度算法，该算法既可以用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将他们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。FCFS算法比较有利于长作业（进程），而不利于短作业（进程）。 2.短作业（进程）优先调度算法 短作业（进程）优先调度算法SJ（P）F，是指对短作业或短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。SJ(P)F调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。该算法对长作业不利，完全未考虑作业的紧迫程度。 3.高响应比优先调度算法 在批处理系统中，短作业优先算法是一种比较好的算法，其主要不足之处是长作业的运行得不到保证。如果我们能为每个作业引人动态优先权，并使作业的优先级随着等待时间的增加而以速率a提高，则长作业在等待一定的时间后，必然有机会分配到处理机。该优先权的变化规律可描述为: 优先权=（等待时间+要求服务时间）/要求服务时间 即优先权=响应时间/要求服务时间 如果作业的等待时间相同，则要求服务的时间越短，其优先权越高，因而该算法有利于短作业。 当要球服务的时间相同时，作业的优先权决定于其等待时间，等待时间越长，优先权越高，因而它实现的是先来先服务 对于长作业，作业的优先级可以随着等待时间的增加而提高，当其等待时间足够长时，其优先级便可以升到很高，从而也可获得处理机。 4.时间片轮转算法 在时间片轮转算法中，系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。当执行的时间片用完时，由一个计数器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。换言之，系统能在给定的时间内响应所有用户的请求。 二、核心算法流程图 课程设计报告 设计名称：模拟实现一种处理机调度算法 学生姓名： xxx 专业：计算机科学与技术 班别： xxxxxxxx 学号： xxxxxx 指导老师： xxxxx 日期： 2014 年 6 月 20 日 初始条件： 1．预备内容：阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解。 2．实践准备：掌握一种计算机高级语言的使用。 要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求） 1．模拟进程调度，能够处理以下的情形： ⑴能够选择不同的调度算法（要求中给出的调度算法）； ⑵能够输入进程的基本信息，如进程名、优先级、到达 时间和运行时间等； ⑶根据选择的调度算法显示进程调度队列； ⑷根据选择的调度算法计算平均周转时间和平均带权周 转时间。 2．设计报告内容应说明： ⑴需求分析； ⑵功能设计（数据结构及模块说明）； ⑶开发平台及源程序的主要部分； ⑷测试用例，运行结果与运行情况分析； ⑸自我评价与总结： i）你认为你完成的设计哪些地方做得比较好或比较出 色； ii）什么地方做得不太好，以后如何改正； iii）从本设计得到的收获（在编写，调试，执行过程中 的经验和教训）； iv）完成本题是否有其他方法（如果有，简要说明该方 法）； 进程调度模拟设计——先来先服务、优先级法1、背景： 当计算机系统是多道程序设计系统时，通常会有多个进程或线程同时竞争CPU。只要有两个或更多的进程处于就绪状态，这种情形就会发生。如果只有一个CPU可用，那么就必须选择下一个要运行的进程。在操作系统中，完成选择工作的这一部分称为调度程序，该程序使用的算法成为调度算法。 进程调度的核心问题是采用什么样的算法把处理机分配给进程，好的算法将提高资源利用率，减少处理机的空闲时间，避免有些作业长期得不到相应的情况发生等，从而设计出受欢迎的操作系统。较常见的几种进程调度算法有：先来先服务调度算法；短作业优先调度算法；时间片轮转调度算法；优先级调度算法；高响应比优先算法和多级反馈队列调度算法等。 2.1设计目的 无论是在批处理系统还是分时系统中，用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。另外，系统进程也同样需要使用处理机。这就要求进程调度程序按一定的策略，动态地把处理机 题目操作系统课程设计 实验一：进程调度算法 1.实验目的 通过优先权法和轮转算法的模拟加深对进程概念和进程调度过程的理解，掌握进程状态之间的切换，同时掌握进程调度算法的实现方法和技巧。2.实验内容 1）用C语言或C++语言来实现对n个进程采用优先权算法以及轮转算法的进程调度。 2）每个用来标识进程的进程控制块PCB用结构来描述，包括以下字段：（1）进程标识ID，其中0为闲逛进程，用户进程标识数为1，2，3…。 （2）进程优先级Priority，闲逛进程（idle）的优先级为0，用户进程的优先级大于0，且随机产生，标识数越大，优先级越高。 （3）进程占用CPU时间CPUtime，进程每运行一次，累计值等于4. （4）进程总共需要运行时间Alltime，利用随机函数产生。 （5）进程状态，0-就绪态；1-运行态；2-阻塞态。 （6）队列指针next，用来将多个进程控制块PCB链接为队列。 3）优先数改变的原则 （1）进程在就绪队列中每呆一个时间片，优先数增加1。 （2）进程每运行一个时间片，优先数减3. 4）在调度前，系统中拥有的进程数PCB_number由键盘输入，经初始化后，所有的进程控制块PCB链接成就绪队列。 3.实验步骤 a)画出程序流程图 a)动态优先权的进程调度算法模拟流程 b)轮转法进程调度算法模拟流程 b)程序算法如下： #include "stdafx.h" #define NULL 0 #include LINUX进程调度算法的分析 何 翔，顾 新 （西安电子科技大学，陕西西安 710071） 摘 要进程调度对一个操作系统来说是至关重要的，它起着非常关键的作用。本文针对Linux操作系统中的普通进程调度算法进行了分析，对以进程为CPU时间分配单位和以用户为CPU时间分配单位的两种算法进行了分析和对比。对它们在不同环境下对进程调度效率和公平性的影响进行了探讨，并总结出它们各自适用的环境。 最后为了进一步提高进程调度的效率和公平性，提出了混合算法的思想。 关键词进程调度；普通进程；动态优先级 中图分类号 TP316 1 前 言 在Linux操作系统中，有两种常用的普通进程 调度算法。它们分别以进程和用户为调度单位来进 行CPU时间的分配。这两种算法分别体现了多进程 环境下系统运行的高效性和多用户环境下的公平 性。但是这两种算法都有各自的适用环境，因此它 们各自都有优缺点。本文从多用户的公平性和多进 程的高效性出发对这两种算法进行了分析和比较， 最后提出了混合算法的思想，使进程调度更加高效 和公平。 2 进程调度 进程调度要满足高效率，公平性，响应时间快，周转时间短和吞吐量大等要求。Linux操作系统的内核根据进程响应时间的情况把进程分为3大类：交互进程；批处理进程；实时进程。内核在此基础上实现了3种不同的调度策略：SCHED_ FIFO(即先进现出策略)；SCHED_RR（即轮转策略）；SCHED_OTHER（适合交互分时的程序）。 进程调度时机，即调度器何时开始启动。可以在以下几个时刻进行进程调度： （1）进程状态转换的时刻； （2）可运行队列中新增加一个进程时； （3）当前进程的时间片用完时； （4）进程从系统返回到用户态时； （5）内核处理完中断后，进程返回到用户态时。 在以上几种情况下进程调度可以解释为在下面几 个状态中进行切换。 进程调度的流程如图1所示。 图1 进程调度的流程图 图1的转换条件如下： （1）调度；（2）时间片用完；（3）跟踪并调度； （4）退出；（5）收到信号并醒来；（6）等待资源 到位再调度；（7）等待资源到位再调度；（8）等待 资源到位；（9）资源到位或收到信号。 3 普通进程调度算法的分析 3.1 按进程调度的算法分析 Schedulue()是按进程调度算法的主要函数， 是系统的核心函数。它的核心代码如下： next=idle_task(this_cpu); 电子科技 2005年第9期（总第192期） 21 进程调度算法的模拟实现 ?实验目的 1．本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。 2．利用程序设计语言编写算法，模拟实现先到先服务算法FCFS、轮转调度算法RR、最短作业优先算法SJF、优先级调度算法PRIOR、最短剩余时间优先算法SRTF。 3．进行算法评价，计算平均等待时间和平均周转时间。 ?实验内容及结果 1．先来先服务算法 2．轮转调度算法 3. 优先级调度算法 4. 最短时间优先算法 5. 最短剩余时间优先算法 ?实验总结 在此次模拟过程中，将SRTF单独拿了出来用指针表示，而其余均用数组表示。 ?完整代码 【Srtf.cpp代码如下：】 //最短剩余时间优先算法的实现 #include 实现进程调度算法 [实验目的] 通过该实验加深和提高对进程调度知识的掌握。 [实验内容及要求] 用C语言实现下列要求，并写出实验报告，报告内容包括:题目、 目的、内容和要求、程序清单、运行情况(输入、输出)、总结。 现有一批给定的进程P1、P2、P3、P4、P5，它们到达时间和要求 运行时间如下： (1)分别输出采用短进程优先调度算法SPF、先来先服务FCFS调度算法时,各进程的周转时间、带权周转时间及平均周转时间和平均带权周转时间，比较两种算法哪个性能好。 (2)输出两种调度算法的进程完成顺序。 源程序为： #include 实验二进程管理 作业（进程）调度算法模拟 1．实验目的与要求 本实验的目的是通过作业或进程调度算法模拟设计，进一步加深对作业或进程调度算法的理解，通过计算平均周转时间和带权平均周转时间，进一步加深对算法的评价方法的理解。 2. 实验类型：验证型 3. 实验学时：4 4. 实验原理和知识点 （1）掌握作业或进程调度算法。 （2）平均周转时间和带权平均周转时间计算。 5. 实验环境（硬件环境、软件环境）： （1）硬件环境：Intel Pentium III 以上CPU，128MB以上内存，2GB以上硬盘。 （2）软件环境：linux操作系统gcc编译器或windows操作系统vc++集成开发环境。 6. 实验内容 设定一组作业或进程，给定相关参数，对这组进程或作业按调度算法实施调度，输出调度次序，并计算平均周转时间和带权平均周转时间。使用的调度算法有： ①先来先服务调度算法。 ②优先级调度算法。 ③短作业（或进程）优先调度算法。 ④响应比高优先调度算法 使用的主要数据结构： （1）定义一个结构体，结构体的主要成员有：序号、作业（进程）号或名称、提交时间、运行时间、优先数、进入输入井时间、开始运行时间、尚需运行时间、运行结束时间、周转时间、带权周转时间、运行次序等。 （2）利用定义的结构体，定义一个结构体数组，用来记录系统中的作业或进程。 算法描述： 1．主控程序算法描述 2．数据输入算法 3．数据输出算法 4．先来先服务调度算法描述 先来先服务调度算法 5．优先级调度算法 6．短作业（或进程）优先调度算法 Rmin 该作业 的运行时间 k 该作业的 在数组中的下标 选择运行时间最短作业的算法 优先级调度算法 在数组中找第一个未运行的作业 Pmin 该作业的优先数 （当前最小的） k 该作业的在数组中的下标 作业的优先数 与Pnim 比较 有未运行的作业 未找到 找到 Pmin 该作业 的优先数 k 该作业的 在数组中的下标 大 进程调度算法模拟 专业：XXXXX 学号：XXXXX 姓名：XXX 实验日期：20XX 年XX 月XX 日 一、实验目的 通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。二、实验要求 编写程序实现对 5 个进程的调度模拟，要求至少采用两种不同的调度算法分别进行模拟调度。 三、实验方法内容 1. 算法设计思路将每个进程抽象成一个控制块PCB，PCB 用一个结构体描述。构建一个进程调度类。将进程调度的各种算法分装在一个类中。类中存在三个容器，一个保存正在或未进入就绪队列的进程，一个保存就绪的进程， 另一个保存已完成的进程。还有一个PCB 实例。主要保存正在运行的进程。类中其他方法都是围绕这三个容器可以这个运行中的PCB 展开。 主要用到的技术是STL 中的vector 以维护和保存进程容器、就绪容器、完成容器。 当程序启动时，用户可以选择不同的调度算法。然后用户从控制台输入各个进程的信息，这些信息保存到进程容器中。进程信息输入完毕后，就开始了进程调度，每调度一次判断就绪队列是否为空，若为空则系统时间加一个时间片。判断进程容器中是否有新的进程可以加入就绪队列。 2. 算法流程图 主程序的框架： 进程调度过程： 3. 算法中用到的数据结构 struct fcfs{ //先来先服务算法从这里开始 char name[10]; float arrivetime; float servicetime; float starttime; float finishtime; float zztime; float dqzztime; }; //定义一个结构体，里面包含的有一个进程相关的信息 4. 主要的常量变量 vector < PCB>m_ProcessQueue; // 进程输入队列 vector 随机进程调度算法
进程调度算法实验报告
进程调度算法模拟 (操作系统课程设计报告)
进程调度算法实验报告
实验一 模拟实现进程调度算法
进程调度算法模拟实验
进程调度算法实验报告
进程调度算法的模拟实现
进程模拟调度算法课程设计
进程调度算法1
进程调度算法模拟程序设计C++
操作系统模拟进程调度算法
模拟一种处理机调度算法
进程调度算法论文优先级调度~
LINUX进程调度算法的分析
操作系统五种进程调度算法的代码
实现进程调度算法
进程调度算法模拟带答案版
操作系统进程调度算法模拟实验报告