操作系统课程设计进程调度的模拟实现
(完整word版)操作系统-进程调度算法设计与实现实验报告

实验报告课程名称操作系统实验名称进程调度算法设计与实现姓名学号专业班级实验日期成绩指导教师(①实验目的②实验设备和环境③实验内容与步骤④实验结果与分析⑤总结,问题及建议)一、内容:设计一个简单的进程调度算法,模拟OS中的进程调度过程二、要求:①进程数不少于5个;②进程调度算法任选;最好选用动态优先数法,每运行一个时间片优先数减3③用C++(或C)语言编程;④程序运行时显示进程调度过程。
三、步骤:①设计PCB及其数据结构:进程标识数:ID进程优先数:PRIORITY(优先数越大,优先级越高)进程已占用时间片:CPUTIME进程尚需时间片:ALLTIME(一旦运行完毕,ALLTIME为0)进程队列指针:NEXT,用来将PCB排成队列进程状态:STATE(一般为就绪,不用)②设计进程就绪队列及数据结构;③设计进程调度算法,并画出程序流程图;④设计输入数据和输出格式;结构格式:当前正运行的进程:0当前就绪队列:2,1,3,4⑤编程上机,验证结果。
四、分析假设调度前,系统中有5个进程,其初始状态如下:①以时间片为单位调度运行;②每次总是从ALLTIME中不为0,且PRIORITY最大的进程调度运行一个时间片;③上述进程运行后其优先数减3,再修改其CPUTIME和ALLTIME,重复②,③④直到所有进程的ALLTIME均变为0。
五、代码#include〈iostream〉#include〈string〉#include<queue〉using namespace std;typedef struct pcb {string pName;//进程名int priorityNumber;//优先数float serviceTime;//服务时间float estimatedRunningtime;//估计运行时间char state;//状态bool operator〈(const struct pcb &a)const {return priorityNumber > a。
操作系统课程设计报告-进程调度的模拟实现

操作系统课程设计报告专业计算机科学与技术学生姓名班级学号指导教师完成日期博雅学院ﻬ题目:进程调度的模拟实现的模拟实现一、设计目的本课程设计是学习完“操作系统原理”课程后进行的一次全面的综合训练,通过课程设计,更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解,加强学生的动手能力。
在多道程序和多任务系统中,系统内同时处于就绪状态的进程可能有若干个。
也就是说能运行的进程数大于处理机个数。
为了使系统中的进程能有条不紊地工作,必须选用某种调度策略,选择一进程占用处理机。
要求学生设计一个模拟处理机调度算法,以巩固和加深处理机调度的概念.二、设计内容1)概述选择一个调度算法,实现处理机调度。
设计要求:1)进程调度算法包括:时间片轮转法,短作业优先算法,动态优先级算法。
2)可选择进程数量3)本程序包括三种算法,用C或C++语言实现,执行时在主界面选择算法(可用函数实现),进入子页面后输入进程数,(运行时间,优先数由随机函数产生),执行,显示结果。
调度时总是选取优先数最大的进程优先运行2.每个进程的优先数,运行时间,由程序任意指定.3.为了调度方便,把进程按给定优先级(动态优先级算法中)从小到大排成一个队列。
按给定运行时间(短作业优先)从小到大排成一个队列用一个变量作为队首指针,指向队列的第一个进程。
4.处理机调度总是选队首进程运行。
由于本实验是模拟处理机调度,所以被选中的进程并不实际的启动运行,而是执行:优先数-1(动态优先级算法中)要求运行时间-1来模拟进程的一次运行。
5.进程运行一次后,若要求运行时间不等于0,则再将它加入队列(动态优先级算法中:按优先数大小插入.),且改变队首指针:若要求运行时间=0,则把它的状态改为完成(C)状态,且退出队列。
(5)对于遇到优先数一致的情况,采用FIFO策略解决.3。
概要设计(1)本程序用两种算法对五个进程进行调度,每个进程可有三个状态,并假设初始状态为就绪状态。
操作系统进程调度算法模拟实验报告

操作系统进程调度算法模拟实验报告一、实验目的本实验旨在深入理解操作系统的进程调度算法,并通过模拟实验来探究不同调度算法之间的差异和优劣。
二、实验原理操作系统的进程调度算法是决定进程执行顺序的重要依据。
常见的调度算法有先来先服务(FCFS)、最短作业优先(SJF)、优先级调度(Priority Scheduling)、轮转法(Round Robin)和多级反馈队列调度(Multilevel Feedback Queue Scheduling)等。
1.先来先服务(FCFS)算法:按照进程到达的先后顺序进行调度,被调度的进程一直执行直到结束或主动阻塞。
2.最短作业优先(SJF)算法:按照进程需要的执行时间的短长程度进行调度,执行时间越短的进程越优先被调度。
3. 优先级调度(Priority Scheduling)算法:为每个进程分配一个优先级,按照优先级从高到低进行调度。
4. 轮转法(Round Robin)算法:将进程按照到达顺序排列成一个队列,每个进程被分配一个时间片(时间量度),当时间片结束时,将进程从队列头取出放置到队列尾。
5.多级反馈队列调度算法:将进程队列分为多个优先级队列,每个队列时间片大小依次递减。
当一个队列中的进程全部执行完毕或者发生阻塞时,将其转移到下一个优先级队列。
三、实验步骤与结果1.实验环境:- 操作系统:Windows 10- 编译器:gcc2.实验过程:(1)首先,设计一组测试数据,包括进程到达时间、需要的执行时间和优先级等参数。
(2)根据不同的调度算法编写相应的调度函数,实现对测试数据的调度操作。
(3)通过模拟实验,观察不同调度算法之间的区别,比较平均等待时间、完成时间和响应时间的差异。
(4)将实验过程和结果进行记录整理,撰写实验报告。
3.实验结果:这里列举了一组测试数据和不同调度算法的结果,以便对比分析:进程,到达时间,执行时间,优先------,----------,----------,-------P1,0,10,P2,1,1,P3,2,2,P4,3,1,P5,4,5,a.先来先服务(FCFS)算法:平均等待时间:3.8完成时间:15b.最短作业优先(SJF)算法:平均等待时间:1.6完成时间:11c. 优先级调度(Priority Scheduling)算法:平均等待时间:2.8完成时间:14d. 轮转法(Round Robin)算法:时间片大小:2平均等待时间:4.8完成时间:17e.多级反馈队列调度算法:第一级队列时间片大小:2第二级队列时间片大小:4平均等待时间:3.8完成时间:17四、实验总结通过上述的实验结果可以得出以下结论:1.在上述测试数据中,最短作业优先(SJF)算法的平均等待时间最短,说明该算法在短作业的情况下能够有效地减少等待时间。
操作系统课程设计报告-进程调度算法模拟

1.课程设计的目的《操作系统原理》课程设计我们专业实践性环节之一,是学习完《操作系统原理》课程后进行的一次较全面的综合练习。
其目的在于加深对操作系统的理论、方法和基础知识的理解,掌握操作系统结构、实现机理和各种典型算法,系统地了解操作系统的设计和实现思路,培养学生的系统设计能力,并了解操作系统的发展动向和趋势。
2.课程设计的内容及要求先来先服务、短作业优先、时间片轮转、基于静态优先级的调度,基于高响应比优先的动态优先级调度算法实现,能够输出调度情况,并计算周转时间和平均周转时间。
要求使用链表,进程个数由用户提供,按照进程的实际个数生成PCB,程序能够让用户选择使用哪种调度算法,能够在Linux环境运行并验证结果。
程序要考虑用户界面的友好性和使用方便性。
进程基本信息可从文件读入,也可手动输入。
3、设计原理3.1先来先服务调度算法每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业,将它们调入内存,为它们分配资源创建进程,然后放入就绪队列3.2短作业优先调度算法短作业优先调度算法是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机时再重新调度。
3.3时间片轮转调度算法系统将所有的就绪进程按先来先服务的原则排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片。
时间片的大小从几ms到几百ms。
当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。
3.4静态优先级调度算法把处理机分配给优先级最高的进程,使之执行。
但在其执行期间,只要出现了另一个比其优先级更高的进程,调度程序就将处理机分配给新到的优先级最高的进程。
这样就可以保证紧迫性作业优先运行。
3.5最高响应比优先的动态优先级调度算法优先权调度算法是为了照顾紧迫型作业,使之在进入系统后便获得优先处理,引入最高优先权优先调度算法。
操作系统进程调度算法模拟(c++)实验报告

操作系统进程调度算法模拟(c++)实验报告南通大学计算机科学与技术学院操作系统课程设计报告书设计题目模拟实现进程调度中的先来先服务算法,短作业优先算法,时间片轮转算法,优先级调度算法专业班级计___学生姓名_____学号 161________日期 20__.01.8-20__.01.12课程设计题目:模拟实现进程调度中的先来先服务算法,短作业优先算法,时间片轮转算法,优先级调度算法一、主要目的模拟实现进程调度中的先来先服务算法,短作业优先算法,时间片轮转算法,优先级调度算法二、设备与环境1.硬件设备:PC机一台2.软件环境:dows操作系统,vc6.0三、实验要求1.实验题目模拟实现进程调度中的先来先服务算法,短作业优先算法,时间片轮转算法,优先级调度算法2.数据结构及主要符号说明。
用两个数组分别表示进程的运行时间和优先级,数组大小定义为 100,用以适应多种进程算法计算在各个算法模块函数中,所有的符号都是采用了同一种浮点型变量符号(如下所示);float t=0;// 保存周转时间和float r=0;// 保存各进程周转时间float T;// 用于保存平均周转时间float S=0;// 用于保存带权周转时间和float s;// 用于保存各程序带权周转时间float W;// 用于保存平均带权周转时间特殊的:在所有算法里出现的“ i ”“j ”均表示计数,在功能函数编写过程中,参数均是以 a, b, c 代替的其中 c 表示固定输入的进程数量,用以作为函数中循环跳出的标志;在时间片轮转算法中,用time表示时间片的大小,用m表示尚未完成的进程数;在时间片轮转算法中,定义了新的数组 d[100] ,用来保存相应的进程运行时间在循环过程中用以操作,避免因操作过程中数值变化无法进行后续操作四、程序流程图和程序先来先服务算法程序及流程图void First(float a[],int c)// 先来先服务算法float t=0;//保存周转时间和float r=0;//保存各进程周转时间float T;//用于保存平均周转时间float S=0;//用于保存带权周转时间和float s;//用于保存各程序带权周转时间float W;//用于保存平均带权周转时间int i;// 计数for(i=1;i=b[j+1]){float m=b[j];b[j]=b[j+1];b[j+1]=m;}}for(i=1;i0)〃时间片轮转,当所有进程执行完毕以后跳出{for(i=1;i0)// 进程完成与否的判断{cout>n;cout>Operation[i]>>Priority[i];system(“cls”);// 清屏/_________按表格显示进程参数 _________/cout<<“输入进程运行时间及优先级如下:”<<endl;cout<<“进程号”<<#;\t#;<<“执行时间”<<#;\t#;<<“优先级”<<#;\n#;;for(i=1;i<=n;i++)cout<<“job”<<i<<#;\t#;<<Operation[i]<<#;\t#;<<#;\t#;<<Priority[i] <<#;\n#;;调用函数调用函数 ________/First(Operation,n);cout<<endl;Short(Operation,n);cout<<endl;Time(Operation,n);cout<<endl;Precedence(Priority,Operation,n); return 0;。
操作系统进程调度模拟课程设计(java)

计算机操作系统课程设计实验报告题目名称进程调度模拟系统院系班级完成时间2013.1.8 指导老师本次实验成绩组长联系电话邮件地址组长(姓名、学号)主要任务需求分析,模块设计与代码编写,组织任务分配,PPT制作,实验报告审定,材料汇总等成员(姓名、学号)主要任务代码的编写实验报告的编写、材料查找等题目进程调度:模拟FCFS和SJF进程调度过程实验介绍原理现在的处理机任务量大,多个进程会不同时先后到达,并且各个进程的工作时间也不一定相同,为了使各个进程间不发生冲突,有条不紊的先后运行,并以最短的时间占用处理机,面对这种发展状况,有必要使用进程调度算法来提高处理机的工作效率。
去选择合适的一种进程调度算法达到理想的效果,可以做到信息的规范管理、科学统计和快速运作,从而减少时间上的浪费。
用Java语句设计实现登陆界面,直观显示各种算法和调度结果,直观地显示运行结果,设计进程调度算法实现用不同算法(先来先服务,短作业优先,高响应比优先调度算法,时间片轮转算法)进行进程调度,算出最短周转时间,实现高效率调度算法。
参考资料[1] 黄祥喜,计算机操作系统实验教程。
广州:中山大学出版社,1994.[2] 汤子瀛,《计算机操作系统(修订版)》西安电子科技大学出版社[3] Andrew S.Tanenbaum,现代操作系统,机械工业出版社。
[4] (美)Bruce Eckel. Java编程思想. 陈昊鹏译. 北京:机械工业出版社,2007[5] 王路群.Java高级程序设计.北京:中国水利水电出版社,2006[6] 孙卫琴. 精通Struts:基于MVC的Java Web设计与开发.北京:电子工业出版社,2004.08实验环境(软件和硬件):(1)硬件要求EGA或VGA卡彩显或单显(640×350以上),单机内存2M以上,硬盘40M 以上。
客户端计算机采用586以上机型,客户端应用程序可以稳定的运行在Windows07 xp操作系统之上。
操作系统课程设计-进程调度算法模拟

操作系统课程设计----进程调度算法模拟一、实验内容:模拟五种进程调度算法并计算各参数值二、实验原理:(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]="";}//---------------------------------------------------------------------------六、实验总结:此次实验花了一周多的时间完成了程序的编写和界面设计,这其中也走了不少弯路。
操作系统进程调度算法模拟实验

操作系统进程调度算法模拟实验进程调度是操作系统中一个重要的功能,它决定了哪些进程能够获得处理器资源以及如何按照一定的策略来分配这些资源。
为了更好地理解进程调度算法的工作原理,我们可以进行一个模拟实验来观察不同算法的表现效果。
实验设想:我们设想有5个进程要运行在一个单核处理器上,每个进程有不同的运行时间和优先级。
进程信息如下:进程A:运行时间10ms,优先级4进程B:运行时间8ms,优先级3进程C:运行时间6ms,优先级2进程D:运行时间4ms,优先级1进程E:运行时间2ms,优先级5实验步骤:1.先来先服务(FCFS)调度算法实验:将上述进程按照先来先服务的原则排序,运行对应的模拟程序,观察每个进程的运行时间、完成时间和等待时间。
2.最短作业优先(SJF)调度算法实验:将上述进程按照运行时间的大小排序,运行对应的模拟程序,观察每个进程的运行时间、完成时间和等待时间。
3.优先级调度算法实验:将上述进程按照优先级的大小排序,运行对应的模拟程序,观察每个进程的运行时间、完成时间和等待时间。
4.时间片轮转(RR)调度算法实验:设置一个时间片大小,将上述进程按照先来先服务的原则排序,运行对应的模拟程序,观察每个进程的运行时间、完成时间和等待时间。
实验结果:通过模拟实验,我们可以得到每个进程的运行时间、完成时间和等待时间。
对于FCFS算法,进程的运行顺序是按照先来先服务的原则,因此进程A首先得到处理器资源并完成运行,其它进程依次按照到达顺序得到资源。
因此,对于进程A、B、C、D、E,它们的完成时间分别是10ms、18ms、24ms、28ms和30ms,等待时间分别是0ms、10ms、18ms、24ms和28ms。
对于SJF算法,进程的运行顺序是按照运行时间的大小,即短作业优先。
因此,进程E首先得到处理器资源并完成运行,其它进程依次按照运行时间的大小得到资源。
对于进程E、D、C、B、A,它们的完成时间分别是2ms、6ms、12ms、20ms和30ms,等待时间分别是0ms、2ms、6ms、12ms和20ms。
操作系统课程设计进程调度模拟设计

课程设计课程名字系统软件开发实训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) 根据选择的调度算法计算平均周转时间和平均带权周转时间。
进程调度模拟实现

操作系统课程设计报告题目:进程调度算法的模拟实现专业计算机科学与技术学生姓名刘远强班级计算机131学号1310704109指导教师韩立毛完成日期2015.7.10信息工程学院目录1 概述 (2)1.1 设计目的 (2)1.2 设计要求 (2)2 设计原理 (2)2.1 先来先服务算法 (2)2.2 短进程优先算法 (2)2.3高优先权优先算法 (2)2.4高响应比优先算法 (2)3 概要设计 (3)3.1 功能结构 (3)4 详细设计 (3)4.1 用户界面模块设计 (3)4.2 算法模块设计 (4)5 测试与分析 (11)5.1 测试方案 (11)5.2 测试结果 (11)5.3 结果分析 (13)6 设计小结 (14)7 参考文献 (14)附录源程序代码 (14)题目:进程调度算法的模拟实现1 概述1.1 设计目的在多道程序和多任务系统中,系统内同时处于就绪状态的进程可能有若干个,也就是说能运行的进程数大于处理机个数。
为了使系统中的进程能有条不紊地工作,必须选用某种调度策略,选择一进程占用处理机。
要求学生设计一个模拟处理机调度算法,以巩固和加深处理机调度的概念。
1.2设计要求a)至少有四种作业调度算法;b)能根据不同的调度算法算出每个作业的周转时间和带权周转时间,并通过一组作业算出系统的平均周转时间和平均带权周转时间,比较各种算法的优缺点;c)设计一个实用的用户界面,以便选择不同的作业调度算法。
2 设计原理2.1 先来先服务算法每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业,将它们调入内存,为它们分配资源创建进程,然后放入就绪队列。
2.2 短进程优先算法短进程优先调度算法是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机时再重新调度。
2.3高优先权优先算法a)当该算法用于作业调度时,系统从后备作业队列中选择若干个优先级最高的,且系统能满足资源要求的作业装入内存运行。
《 操作系统C 》操作系统进程调度模拟

(5)进程的阻塞时间STARTBLOCK,表示当进程再运行STARTBLOCK个时间片后,进程将进入阻塞状态。
(6)进程被阻塞的时间BLOCKTIME,表示已阻塞的进程再等待BLOCKTIME个时间片后,将转换成就绪状态。
1)、进程添加,如图:
2)、正常运行情况下,如图:
图(1)
3)、发生中断情况下,如图:
4.实验结果分析
在时间按片轮转算法(RR)中,时间片的大小对系统性能有着很大的影响,如果选择很小的时间片将有利于短作业,因为它能较快地完成任务,但会频繁的发生中断、进程上下文的切换,从而增加系统的开销;反之,如果选择太长的时间片,使每个进程都能在一个时间片内完成,时间按片轮转算法(RR)就退化成先来先服务(FCFS)算法了,从而无法满足交互式用户的需求。一个较为可取的大小是,时间片大小略大于一次典型的交互式需要所需求的时间。这样可以使大多数进程在一个时间片内完成。
booleanSusp=false; /*增加进程标志*/
publicRR(){
/*线程*/
myThread=newThread(this);
myThread.start();
/*程序窗口初始化*/
JFrame f=newJFrame();
f.setTitle("时间片轮转调度算法(RR)");
f.setSize(650,450);
if(e.getSource() == jbBegin){
if(Continue==false)
Continue=true;
}
if(e.getSource() == jbAdd){
操作系统 进程调度模拟实验

实验一进程调度实验◆实验名称:进程调度实验◆仪器、设备:计算机◆参考资料:操作系统实验指导书◆实验目的:设计一个有N个进程并行的进程调度程序◆实验内容:进程调度算法:采用最高优先级优先的调度算法。
每个进程有一个进程控制块(PCB)表示。
进程控制块可以包含进程名、优先级、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。
进程名、优先级、需要运行时间通过键盘输入。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
运行一个时间片后,进程的已占用CPU时间已达到所需要的运行时间,则撤消该进程,否则将进程的优先级减1(即降低一级),然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB,以便进行检查。
重复以上过程,直到所有进程都完成为止。
调度算法的流程图如下:◆实验原理、数据(程序)记录:进程调度源程序如下:#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0struct pcb { /* 定义进程控制块PCB */char name[10];char state;int super;int ntime;int rtime;struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB;void sort() /* 建立对进程进行优先级排列函数*/{PCB *first, *second;int insert=0;if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/ {p->link=ready;ready=p;}else /* 进程比较优先级,插入适当的位置中*/{first=ready;second=first->link;while(second!=NULL){if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/{ /*插入到当前进程前面*/p->link=second;first->link=p;second=NULL;insert=1;}else /* 插入进程优先数最低,则插入到队尾*/ {first=first->link;second=second->link;}}if(insert==0) first->link=p;}}void input() /* 建立进程控制块函数*/{int i,num;//clrscr(); /*清屏*/printf("\n 请输入进程数?");scanf("%d",&num);for(i=0;i<num;i++){printf("\n 进程号No.%d:\n",i);p=getpch(PCB);printf("\n 输入进程名:");scanf("%s",p->name);printf("\n 输入进程优先级:");scanf("%d",&p->super);printf("\n 输入进程运行时间:");scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='w';p->link=NULL;sort(); /* 调用sort函数*/}}int space(){int l=0; PCB* pr=ready;while(pr!=NULL){l++;pr=pr->link;}return(l);}void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/{printf("\n qname \t state \t super \t ndtime \t runtime \n");printf("|%s\t",pr->name);printf("|%c\t",pr->state);printf("|%d\t",pr->super);printf("|%d\t",pr->ntime);printf("|%d\t",pr->rtime);printf("\n");}void check() /* 建立进程查看函数*/{PCB* pr;printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/ disp(p);pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){disp(pr);pr=pr->link;}}void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/{printf("\n 进程[%s] 已完成.\n",p->name);free(p);}void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ {(p->rtime)++;if(p->rtime==p->ntime)destroy(); /* 调用destroy函数*/else{(p->super)--;p->state='w';sort(); /*调用sort函数*/}}void main() /*主函数*/{int len,h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ch=getchar();h++;printf("\n The execute number:%d \n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';check();running();printf("\n 按任一键继续......");ch=getchar();}printf("\n\n 进程已经完成.\n");ch=getchar();}◆实验结果及分析通过实验,实现了采用最高优先级优先的调度算法进行进程调度的模拟。
操作系统课程设计——进程调度模拟算法(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先到先服务算法描述:把所有进程按到达先后排序,每次取最先到的进程执行后淘汰,再取下一个,直到所有进程调度完毕。
操作系统实验进程调度

实验三进程调度一. 实验目的加深理解并模拟实现进程(作业)调度算法。
1)熟悉常用的进程调度算法, 如FCFS、SPF、FPF、高响应比优先、时间片轮转;2)结合所学的数据结构及编程知识, 选择三种进程调度算法予以实现。
二. 实验属性该实验为设计性实验。
三. 实验仪器设备及器材普通PC386以上微机四. 实验要求本实验要求2学时完成。
1)本实验要求完成如下任务:2)编程实现单处理机系统中的进程调度, 要求从FCFS、SPF、FPF、高响应比优先、时间片轮转算法中至少选择三个;3)最后编写主函数对所做工作进行测试。
实验前应复习实验中所涉及的理论知识和算法, 针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。
实验后认真书写符合规范格式的实验报告(参见附录A), 并要求用正规的实验报告纸和封面装订整齐, 按时上交。
五: 实验具体设计此程序模拟了两种调度算法, FCFS和SPF, 首先FCFS就是按照进程的创建顺序依次顺序进行, 流程图为:进程顺序执行SPF:每次都进行循环, 选出在该时间刻运行时间最短的进程优先执行。
1.程序代码具体详解:2.创建一结构体作为进程控制器typedef struct PCB{int ID;char state;int arrivetime;int starttime;int finishtime;int servicetime;struct PCB *next;}pcb;定义全局变量作为计时器int time;//计时器创建进程链表:从txt文件中读取数据, 构造一条不含头结点的单链表void Create_process(){ifstream inFile;inFile.open("test.txt");inFile>>n;inFile.get();int i=0;for (;i<n;i++){p=(pcb *)malloc(sizeof(pcb));inFile>>p->ID;inFile>>p->arrivetime;inFile>>p->servicetime;p->starttime=0;p->finishtime=0;p->state='F';p->next=NULL;if(head==NULL){head=p;q=p;time=p->arrivetime;}if(p->arrivetime < time)time=p->arrivetime;q->next=p;q=p;}若执行FCFS算法, 按顺序遍历链表void fcfs1(){int i;p=head;for(i=0;i<n;i++){if(p->state=='F')q=p;run_fcfs1(q);}p=p->next;}}void run_fcfs1(pcb *p1){time = p1->arrivetime > time? p1->arrivetime:time;p1->starttime=time;printf("\n现在时间: %d,开始运行作业%d\n",time,p1->ID);time+=p1->servicetime;p1->state='T';p1->finishtime=time;printf("ID号到达时间开始运行时间服务时间完成时间\n");printf("%d%10d%12d%12d%12d\n",p1->ID,p1->arrivetime,p1->starttime,p1->servicetime,p 1->finishtime);}若执行SPF算法, 每次都从链表头开始遍历链表, 找出arrivetime<=time并且运行时间最短的节点, 执行该节点进程, 最后再删除该节点。
操作系统课程设计-进程调度的模拟实现

课程设计题目进程调度算法模拟编程学生姓名学号专业计算机科学与技术班级指导教师完成日期2012年12月18日进程调度的模拟实现摘要:进程管理是操作系统中的重要功能,用来创建进程、撤消进程、实现进程状态转换,它提供了在可运行的进程之间复用CPU的方法。
在进程管理中,进程调度是核心,因为在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态,当就绪进程个数大于处理器数目时,就必须依照某种策略决定哪些进程优先占用处理器。
本文通过两种算法模拟实现了进程之间的调度。
关键词:进程创建,先来先服务,优先级调度。
一.前言在操作系统中,调度的实质是一种资源分配,调度算法即指:根据系统的资源分配策略所规定的资源分配算法。
对于不同的系统和系统目标,通常采用不同的调度算法,如在批处理系统中,为照顾为数众多的短作业,采用短作业有限调度算法;在分时系统中,为保证系统具有合理的响应时间,采用轮转法进行调度。
采用算法时,则要考虑多方面因素,以便达到最佳效果。
做好这个课程设计,有利于加深对操作系统进程调度知识的理解。
二. 系统总体框架设计本程序采用两种算法(最高优先级数优先的调度算法和先来先服务算法)对多个进程进行调度,每个进程有三个状态,初始状态为就绪状态。
最高优先级数优先的调度算法中,程序的某进程运行时间以时间片为单位计算。
各进程的优先数或轮转时间数以及进程需运行的时间片数的初始值均由用户给定。
在优先级数优先的调度算法中,优先级数的值设计为100与运行时间的差值,即Pro_time-process->needtime。
进程每执行一次,优先数减3,CPU时间片数加1,进程还需要的时间片数减1。
对于遇到优先数一致的情况,采用先来先服务策略解决。
程序设计组成框图程序流程图1.可强占优先调度算法实现过程流程图:开始创建进程及属性先来先服务算法优先数调度算法显示进程执行状态结束2先来先服务调度算法实现过程流图三.数据结构设计1.设计创建进程的结构类型定义和结构变量说明struct ProcessPcb,定义PCB相关变量:ProcessPcb(){next=NULL;}charpro_name[20]; //进程的名字ﻩint time_submit ; //提交时间,从时间为1开始计时inttime_exe ; //进程所需的运行时间ﻩintpro_id ;//进程ID(系统生成)ﻩint pro_priority ; //进程优先级ﻩint time_start ; //开始执行的时间ﻩint time_end ; //结束的时间ﻩint time_wait ; //等待的时间ﻩint pro_state; //进程的状态(就绪,执行,完成) int time_left ; //还需多少时间单位,初始化为所需的执行时间int time_turn;ﻩ //周转时间ﻩdouble time_aver ; //带权周转时间2.创建PCB类class CpuModel,定义程序中使用的各函数:CpuModel{CpuModel(){pcbnum=0;}voidcpurun(); //cpu模拟运行函数ﻩbool GetPcb(); //进程输入函数ﻩvoid ShowPcb(); //将输入的进程展示出来voidPriModel(); //可强占的优先进程调度模式void FcfsModel(); //先到先服务调度模式ProcessPcb PcbList[100];ﻩ//按提交时间排的未就绪进程队列()}四.测试结果及分析1.开始运行,显示:2.输入进程数,各进程属性:关于提交时间执行时间等,将检测输入是否数字,不是数字即退出程序。
模拟进程调度功能的设计与实现操作系统课程设计(JAVA版本)

模拟进程调度功能的设计与实现操作系统课程设计(J A V A版本)本页仅作为文档页封面,使用时可以删除This document is for reference only-rar21year.March操作系统课程设计--进程调度子系统模拟实现一、设计内容及意义1.课程设计内容使用java语言或C++语言编程实现模拟操作系统进程调度子系统的基本功能;实现先来先服务、时间片轮转、多级反馈轮转法对进程进行的调度过程;掌握各个调度算法的特点。
2.该课程设计意义理解进程调度的概念深入了解进程控制块的功能、进程的创建、删除以及进程各个状态间的转换过程从实用的角度对《数据结构》课程内容进行更深入理解和更熟练的应用进一步练习对Java及C++语言的熟练使用二、设计方案1.硬件环境PC一台2.开发语言及工具操作系统:MS windows XPC++版:Visual Studio 2008 + MFCJava版:Eclipse + Java Swing3.设计思路系统设备表用于存取调度过程中进程可申请的资源进程控制块主要负责具体进程信息的保存等待队列、就绪队列、完成队列用于保存执行过程的状态信息进程调度进程(类、线程)在就绪队列与等待队列之间进行调度主界面显示调度过程的三个队列的状态信息用户创建进程放入就绪队列等待调度三、功能模块设计1.进程状态转换等待就绪执行创建进程进程结束2.PCB信息主要负责保存各进程基本信息提供外部状态设置和读取接口3.系统设备类系统设备的基本信息设备状态设置、读取接口4.调度类向就绪队列添加新创建进程从就绪队列取相应进程执行将执行阻塞进程放入等待队列检测系统设备表,分配、释放设备、唤醒等待进程执行完成程序放入完成队列(仅为保存状态,非系统部分)提供获取执行状态的外部接口,即各个队列数据的获取5.视图类提供用户操作接口(调度策略选择、进程创建)显示各队列状态信息创建进程调度类线程,调用调度类的接口四、程序总控流程图1.用户接口、调度算法、进程状态转换关系示意系统总体设计页面 12.调度算法基本工作流程示意用户选择进程调度算法创建进程根据算法从就绪队列调度某一时刻需要资源从就绪队列取出执行放入等待队列Y执行完毕资源满足YY就绪队列是否有进程等待执行N初始化进程基本信息将进程放入就绪队列页面 1进程调度框架五、 数据结构设计1. PCB (进程基本信息)类结构ProcessPCB--------Pid Pname userName Priotity subtime totalTime runTimeDcRequestLst: int : String : String : int : int : int : int: List<DeviceReq>说明1. pid 进程ID2.pName进程名erName进程用户4.priority进程优先级5.subtime进程提交时间6.totalTime进程需要执行的总时间7.runtime进程已经运行时间8.dcReqlst当前进程所需要的设备请求表2.Dispatcher(进程调度进程)类结构Dispatcher-------SystimeisContentionpreLstwaitLstfinishLstexecutingsysDcLst: int: boolean: List<Process>: List<Process>: List<Process>: Process: List<Process>说明1.sysTime系统时间2.isContention当前调度是否为抢占方式3.prelst就绪队列4.waitlst等待队列5.finishlst完成队列6.executing正在执行的进程7.sysDclst系统设备表3.Device(系统设备)类结构Device------dcIddcTypedcDiscdcTimedcPiddcleftTime: int: int: String: int: int: int说明1. dcid 设备标识2. dcType 设备类型3. dcTime 该设备一次I/O 服务需要时间4. dcPid 使用该设备的进程5. dcDisc 设备描述6. dcLefTime 设备剩余服务时间六、 程序代码结构1. 类层次关系0..10..*0..10..*0..10..*DispatcherFIFODispatcherPLevelDispatcherRRDispatcherMRDispatcherProcessPCBDeviceDeviceReq2. 详细说明Dispatcher 定义进程调度进程的基本信息和接口FIFODispatcher 、PLevelDispatcher 、RRDispatcher 、MRDispatcher 分别实现相应的调度算法 Device 为系统设备DeviceReq 为进程设备请求,包括请求设备ID 和时间七、 代码实现分析1. 算法分析(各算法过程见下流程图)设备的分配释放先来先服务优先级调度时间片轮转多级反馈轮转设备分配释放页面 1先进先出进程调度算法页面 1优先级进程调度算法(抢占式)页面 1时间片轮转调度算法页面 1多级反馈轮转调度算法(抢占式)页面 12.具体实现(代码部分有详细注释)进程的插入@Overridepublic void addPreProc(Process proc) { 3.算机操作系统教程第2版.清华大学出版社2000年4.著作:[2] 张尧学.计算机操作系统教程第2版习题与实验指导. 清华大学出版21。
模拟进程调度功能的设计与实现操作系统课程设计(含源文件)

目录1、设计目的意义 (2)1.1、目的意义 (2)1.2、实现目标 (2)2、设计方案 (3)2.1、软硬件环境 (3)2.2、开发工具 (3)2.3、思路 (3)3、程序功能模块设计 (4)3.1、总体模块 (4)3.2、部分模块 (4)3.3、详细功能描述 (6)4、程序总控流程图 (6)5、数据结构设计 (8)5.1、PCB结构 (8)5.2、进程状态结构 (8)5.3、控件结构 (9)6、程序代码结构 (9)7、程序主要代码解析 (10)8、测试数据及测试结果 (15)8.1、运行时部分界面 (15)8.2、数据测试记录 (17)9、设计过程中遇到的问题及解决方法……………………………………………………………1810、结论 (18)10.1、系统实现情况 (18)10.2、系统特点 (18)10.3、设计体会及收获 (18)11、参考资料 (19)模拟进程调度功能的设计与实现1、设计目的意义1.1、目的意义●通过课程设计理解进程调度的概念,深入了解进程控制的功能、进程的创建、删除以及进程各个状态间的转换过程;实现先来先服务、时间片轮转、最短作业优先、优先级调度算法对进程进行的调度过程;通过观察有关的队列结构的内容的动态变化过程深入体会各个调度算法的特点;从而能够更好的巩固从书本上学到的知识。
●编程过程中需要建立队列等结构进行各种操作,通过该次课程设计,我们更加从实用的角度对《数据结构》课程内容进行更深入理解和更熟练的应用。
●使用C++语言进行编程,通过对调度功能的编程实现,不但能有效训练我们对编程语言的熟练使用,还能促进我们独立思考解决问题、以及独立查新获取知识的能力。
1.2、实现目标初始态、执行状态、状态。
通过系统设计,实现进程相关数据结构的创建和查看功能;实现多种进程调度算法:先来先服务算法、优先级调度算法、时间片轮转法等;实现对执行进程的阻塞,对等待进程的唤醒等功能。
进程的转换过程如下2、设计方案2.1 软硬件环境●硬件设备: PC机●软件设备:WINDOWSXP、Microsoft Visual C++ 6.02.2、开发工具●由于现在使用的操作系统大多数都是微软公司的产品,为了更好更贴近的模拟操作系统中进程调度功能,我们选择使用C++语言,开发平台Microsoft Visual C++ 6.0,借助MFC来完成应用Windows应用程序的开发。
操作系统进程调度模拟程序实验报告

操作系统进程调度模拟程序实验报告一、实验目的本次实验旨在通过编写一个模拟操作系统进程调度的程序,以加深对进程调度算法的理解。
二、实验内容1. 实现进程相关的数据结构:进程PCB(Process Control Block)。
2.实现进程的创建、撤销以及调度等操作函数。
3. 实现常见的进程调度算法:先来先服务(FCFS)、最短作业优先(SJF)、轮转调度(RR)、优先级调度(Priority)。
4.编写测试程序,验证实现的进程调度算法在不同场景下的表现。
三、实验过程及结果1.进程PCB的设计与实现进程PCB是进程的核心数据结构,用于存储和管理进程相关的信息,包括进程状态(就绪、运行、阻塞)、优先级、执行时间等。
2.进程的创建、撤销及调度函数的实现(1)进程创建函数:实现进程的创建,包括为其分配空间、初始化进程PCB等。
可以根据实际需求,设定进程的优先级、执行时间等属性。
(2)进程撤销函数:实现进程的撤销,包括释放其占用的资源、回收其使用的空间等。
(3)进程调度函数:根据不同的调度算法,实现进程的调度。
可以通过设置时间片大小、优先级设定等方式,实现不同调度算法的效果。
3.进程调度算法的设计与实现(1)先来先服务(FCFS)调度算法:按照进程到达的先后顺序,依次进行调度。
(2)最短作业优先(SJF)调度算法:根据进程的执行时间,选择执行时间最短的进程进行调度。
(3)轮转调度(RR)算法:按照时间片的大小进行调度,每个进程在一个时间片内执行,超过时间片后,暂停并进入等待队列,让其他进程执行。
(4)优先级调度(Priority)算法:根据进程的优先级,选择优先级最高的进程进行调度。
4.测试程序编写测试程序,模拟不同的进程到达顺序、执行时间和优先级等场景,验证不同调度算法的表现。
四、实验结果与分析通过测试程序的运行结果,观察不同调度算法的特点和效果。
可以得出以下结论:1.FCFS算法适用于进程到达时间差异较大的场景,保证了先到先服务。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
课程设计题目进程调度算法模拟编程学生姓名学号专业计算机科学与技术班级指导教师完成日期2012年12月18日进程调度的模拟实现摘要:进程管理是操作系统中的重要功能,用来创建进程、撤消进程、实现进程状态转换,它提供了在可运行的进程之间复用CPU的方法。
在进程管理中,进程调度是核心,因为在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态,当就绪进程个数大于处理器数目时,就必须依照某种策略决定哪些进程优先占用处理器。
本文通过两种算法模拟实现了进程之间的调度。
关键词:进程创建,先来先服务,优先级调度。
一.前言在操作系统中,调度的实质是一种资源分配,调度算法即指:根据系统的资源分配策略所规定的资源分配算法。
对于不同的系统和系统目标,通常采用不同的调度算法,如在批处理系统中,为照顾为数众多的短作业,采用短作业有限调度算法;在分时系统中,为保证系统具有合理的响应时间,采用轮转法进行调度。
采用算法时,则要考虑多方面因素,以便达到最佳效果。
做好这个课程设计,有利于加深对操作系统进程调度知识的理解。
二. 系统总体框架设计本程序采用两种算法(最高优先级数优先的调度算法和先来先服务算法)对多个进程进行调度,每个进程有三个状态,初始状态为就绪状态。
最高优先级数优先的调度算法中,程序的某进程运行时间以时间片为单位计算。
各进程的优先数或轮转时间数以及进程需运行的时间片数的初始值均由用户给定。
在优先级数优先的调度算法中,优先级数的值设计为100与运行时间的差值,即Pro_time-process->needtime。
进程每执行一次,优先数减3,CPU 时间片数加1,进程还需要的时间片数减1。
对于遇到优先数一致的情况,采用先来先服务策略解决。
程序设计组成框图数据项作用pro_name 进程名称time_submit 进程创建时刻pro_id 进程号,当进程有相同名称时,用来区分进程time_start 进程启动时刻time_exe 进程要求运行时间time_end 进程结束的时刻pro_priority 进程优先级图1-2 进程控制块CpuModel类成员作用Cpurun() Cpu模拟运行函数CreatePcb() 进程创建函数ShowPcb() 进程显示函数PriModel() 实现优先级调度算法FcfsModel() 实现先来先服务算法pcbnum 进程数量freetime Cpu空闲时间allturn 总周转时间allaver 总带权周转时间PcbList[] 进程就绪队列的实现图1-3CpuModel类程序流程图1.可强占优先调度算法实现过程流程图:开始创建进程及属性先来先服务算法 优先数调度算法显示进程执行状态结束2先来先服务调度算法实现过程流图三.数据结构设计1.设计创建进程的结构类型定义和结构变量说明struct ProcessPcb,定义PCB相关变量:ProcessPcb(){next=NULL;}char pro_name[20]; //进程的名字int time_submit ; //提交时间,从时间为1开始计时int time_exe ; //进程所需的运行时间int pro_id ; //进程ID(系统生成)int pro_priority ; //进程优先级int time_start ; //开始执行的时间int time_end ; //结束的时间int time_wait ; //等待的时间int pro_state ; //进程的状态 (就绪,执行,完成)int time_left ; //还需多少时间单位,初始化为所需的执行时间int time_turn ; //周转时间double time_aver ; //带权周转时间2.创建PCB类class CpuModel,定义程序中使用的各函数:CpuModel{CpuModel(){pcbnum=0;}void cpurun(); //cpu模拟运行函数bool GetPcb(); //进程输入函数void ShowPcb(); //将输入的进程展示出来void PriModel(); //可强占的优先进程调度模式void FcfsModel(); //先到先服务调度模式ProcessPcb PcbList[100]; //按提交时间排的未就绪进程队列()}四.测试结果及分析1.开始运行,显示:2.输入进程数,各进程属性:关于提交时间执行时间等,将检测输入是否数字,不是数字即退出程序。
3.显示已创建的各进程及其属性:此处的优先级数,是用100减去执行时间。
对于优先级数相同,则默认FIFO。
4.测试可强占的优先进程调度:一次调度完成,将计算此次运行中CPU的利用率。
5.先到先服务调度算法运行情况:6.选择5,回车,退出程序。
五.设计心得在学完操作系统课程之后,一直对进程调度这一块不是很理解,借着做课程设计的机会,我就选择了进程调度模拟编程这个题目,打算在做课程设计的过程中好好的再学习一下这块的知识。
我在做课程设计的过程中,遇到了许多的问题,通过请教同学,上网查资料等途径一一解决。
通过这次操作系统的课程设计,我研究了进程调度的相关知识,加深了对进程调度的理解。
课程设计和平时的实验课比较起来有很大的差距,实验课只是将这一章的一部分内容练习操作一遍,而课程设计需要的是他们综合起来的东西,这要更难一些。
总体来说我认为操作系统这门学科在计算机科学当中是非常重要的,这次操作系统的课程设计收获颇丰,复习了许多东西,也从新学会了许多东西,我想这也许就是课程设计的最终目的吧。
参考文献[1]刘振安、刘燕君著.《C++程序设计课程设计》.北京: 机械工业出版社,2004[2][美]Abraham Silberschatz, Peter Baer Galvin, Greg Gagne 著. 郑扣根译. 操作系统概念(第六版). 北京:高等教育出版社,2004[3]陈向群,向勇等. Windows操作系统原理(第二版). 北京:机械工业出版社,2004.[4]费翔林,李敏,叶保留等.Linux操作系统实验教程.北京:高等教育出版社,2009附录:#include <iostream.h>#include <queue>#include <string>#include <windows.h>#include <malloc.h>using namespace std ;//进程的状态#define UNREADY 0 //未就绪#define READY 1 //就绪#define EXECUTE 2 //执行#define END 3 //完成//进程的PCB结构类型定义和结构变量说明struct ProcessPcb{ProcessPcb(){next=NULL;}char pro_name[20]; //进程的名字int time_submit ; //提交时间,从时间的1开始计时int time_exe ; //进程所需的运行时间int pro_id ; //进程ID(系统生成)int pro_priority ; //进程优先级int time_start ; //开始执行的时间int time_end ; //结束的时间int time_wait ; //等待的时间int pro_state ; //进程的状态 (就绪,执行,完成) int time_left ; //还需多少时间单位,初始化为所需的执行时间int time_turn ; //周转时间double time_aver ; //带权周转时间ProcessPcb *next;};//封装CPU调度与分配程序模块。
进程类class CpuModel{public:CpuModel(){pcbnum=0;}void cpurun(); //cpu模拟运行函数bool CreatePcb(); //进程输入函数void ShowPcb(); //将输入的进程展示出来void PriModel(); //可强占的优先进程调度模式void FcfsModel(); //先到先服务调度模式private:ProcessPcb PcbList[100]; //按提交时间排的未就绪进程队列int pcbnum ; //进程数量int freetime ; //cpu空闲时间int allturn ; //总周转时间float allaver ; //总带权周转时间};#include<algorithm>//cpu模拟运行函数void CpuModel::cpurun(){int choose = 0 ;while(1){cout<<"*** 主菜单 ***"<<endl;cout<<"----------------------------------"<<endl;cout<<"*** 1: 创建进程 ***"<<endl;cout<<"*** 2: 显示已创建的进程 ***"<<endl;cout<<"*** 3: 可强占的优先进程调度 ***"<<endl;cout<<"*** 4: 先到先服务调度 ***"<<endl;cout<<"*** 5: 退出系统 ***"<<endl;cout<<"\n*** 请选择 : " ;cin>>choose ;cout<<endl ;switch(choose){case 1:CreatePcb(); //创建进程break;case 2:ShowPcb(); //显示已创建的进程break;case 3:PriModel(); //可强占的优先进程方式 break;case 4:FcfsModel(); //先到先服务调度方式 break;case 5:return ; //结束程序}cout<<endl;}}//按进程提交时间排序的比较函数bool cmp(ProcessPcb a,ProcessPcb b){if(a.time_submit<b.time_submit)return true;return false;}//判断是否数字int isnumber(char a[]){int len=strlen(a);int i,num=0;if(a[0]>'0'&&a[0]<='9')num=a[0]-'0';else return -1;for(i=1;i<len;i++){if(a[i]>='0'&&a[i]<='9')num=num*10+a[i]-'0';else return -1;}return num;}//进程输入函数bool CpuModel::CreatePcb(){char num[10];cout<<"\n***请输入你想建立的进程个数: ";cin>>num; //输入进程个数pcbnum=isnumber(num);if(pcbnum<=0){cout<<"***输入有错***\n";return 0;}int i;for(i=0;i<pcbnum;i++) //输入进程信息{cout<<"***请依次输入第"<<i+1<<"个进程的信息***"<<endl ;cout<<"*******名字:" ;cin>>PcbList[i].pro_name ;cout<<"***提交时间:";cin>>num;PcbList[i].time_submit=isnumber(num);if(PcbList[i].time_submit<=0){cout<<"***输入有错***\n";return 0;}cout<<"***执行时间:";cin>>num;PcbList[i].time_exe=isnumber(num);if(PcbList[i].time_exe<=0){cout<<"***输入有错***\n";return 0;}PcbList[i].time_left=PcbList[i].time_exe; //设置剩余执行时间PcbList[i].pro_state=UNREADY; //设置状态为未就绪PcbList[i].pro_priority=100-PcbList[i].time_exe; //设置优先级,优先级=100-执行时间cout<<endl ;}sort(PcbList,PcbList+pcbnum,cmp); //按提交时间排序for(i=0;i<pcbnum;i++)PcbList[i].pro_id=i+1; //设置Id,根据提交时间return 1;}//展示所需执行进程信息void CpuModel::ShowPcb(){int i;cout<<"\n***所需执行的进程信息如下***\n";for(i=0;i<pcbnum;i++)cout<<" 进程编号: "<<PcbList[i].pro_id<<" 进程名字: "<<PcbList[i].pro_name <<" 提交时间: "<<PcbList[i].time_submit<<" 执行时间: "<<PcbList[i].time_exe <<" 优先级数:"<<PcbList[i].pro_priority<<endl ;cout<<endl;}//可强占的优先进程调度模式void CpuModel::PriModel(){cout<<"********可强占的优先进程调度过程如下********\n";freetime=0; //初始化系统空闲时间为0int time=0; //时间int nextid=0;int pnum=0; //已就绪进程数目ProcessPcb *head; //就绪队列ProcessPcb *pcb,*pcb1,*pcb2;head=(ProcessPcb*)malloc(sizeof(ProcessPcb));head->next=NULL; //head 指针不用,head->next开始为就绪队列//模拟cpu开始工作while(head->next!=NULL||pnum<pcbnum){Sleep(1000);time++; //时间片为1cout<<"*Time: 第"<<time<<"秒"<<endl; //打印// 进程就绪(查看未就绪的进程中在该时间片是否可以进入就绪队列)while(pnum<pcbnum && PcbList[pnum].time_submit<=time){pcb=(ProcessPcb*)malloc(sizeof(ProcessPcb));*pcb=PcbList[pnum++];//进入就绪队列pcb->next=head->next; //插在head之后head->next=pcb;}//查找在time时间片应该运行的进程if(head->next==NULL){cout<<" 没有可运行的进程"<<endl;freetime++;}else{pcb2=head;pcb=head->next;pcb1=head->next;//查找当前优先级最高的就绪进程while(pcb1->next!=NULL){if(pcb->pro_priority<=pcb1->next->pro_priority){pcb2=pcb1;pcb=pcb1->next;}pcb1=pcb1->next;}//运行优先级最高的进程if(pcb->time_left==pcb->time_exe) //该进程是否已开始{pcb->time_start=time; //设置开始时间 pcb->pro_state=EXECUTE; //设置状态为执行 }pcb->pro_priority=pcb->pro_priority-3; //优先级数减3 pcb->time_left--; //剩余执行时间减去时间片1//打印该进程信息cout<<" 进程编号: "<<pcb->pro_id<<" 进程名字:"<<pcb->pro_name<<" 提交时间: "<<pcb->time_submit<<" 执行时间: "<<pcb->time_exe<<"\n 开始时间: "<<pcb->time_start <<" 还剩时间: "<<pcb->time_left<<" 优先级数:"<<pcb->pro_priority<<endl ;//该进程是否执行结束if(pcb->time_left==0){pcb2->next=pcb2->next->next;//将其在就绪队列中出列 pcb->time_end=time; //设置结束时间 pcb->time_turn=pcb->time_end-pcb->time_submit+1; //计算周转时间pcb->time_aver=pcb->time_turn/(double)pcb->time_exe;//计算带权周转时间pcb->pro_state=END;cout<<"\n进程"<<pcb->pro_id<<"运行结束:"<<"\n 进程名字: "<<pcb->pro_name<<" 提交时间: "<<pcb->time_submit<<" 执行时间: "<<pcb->time_exe<<" 开始时间: "<<pcb->time_start<<" 结束时间: "<<pcb->time_end<<"\n 周转时间: "<<pcb->time_turn<<"带权周转时间: "<<pcb->time_aver<<endl ;}}}//模拟CPU工作结束cout<<"\n 所有进程运行完毕!"<<endl;double c=(time-freetime)/(double)time*100;cout<<"\n cpu利用率:"<<c<<"%"<<endl;} //可强占的优先进程调度模式结束//先到先服务调度模式void CpuModel::FcfsModel(){cout<<"********先到先服务进程调度过程如下********\n";freetime=0; //初始化系统空闲时间为0int time=0; //时间int pnum=0; //已就绪进程数目ProcessPcb que[100]; //就绪队列int quef=0,quee=0; //就绪队列的头指针和尾指针//模拟cpu开始工作while(quef<quee||pnum<pcbnum){Sleep(1000);time++; //时间片为1cout<<"*Time: 第"<<time<<"秒"<<endl; //打印//进程就绪(查看未就绪的进程中在该时间片是否可以进入就绪队列)while(pnum<pcbnum && PcbList[pnum].time_submit<=time)que[quee++]=PcbList[pnum++];//查找time时间片的运行进程if(quef==quee){cout<<" 没有可运行的进程"<<endl;freetime++;}else{//运行进程if(que[quef].time_left==que[quef].time_exe) //该进程是否已开始{que[quef].time_start=time; //设置开始时间que[quef].pro_state=EXECUTE; //设置状态为执行}que[quef].time_left--; //剩余执行时间减去时间片1//打印进程信息cout<<" 进程编号: "<<que[quef].pro_id<<" 进程名字: " <<que[quef].pro_name<<" 提交时间: "<<que[quef].time_submit<<" 执行时间: "<<que[quef].time_exe<<"\n 开始时间: "<<que[quef].time_start<<" 还剩时间: "<<que[quef].time_left<<endl ;//该进程是否执行结束if(que[quef].time_left==0){que[quef].time_end=time;que[quef].time_turn=que[quef].time_end-que[quef].time_submit+1;que[quef].time_aver=que[quef].time_turn/(double)que[quef].time_exe;que[quef].pro_state=END;cout<<"\n进程"<<que[quef].pro_id<<"运行结束:"<<"\n 进程名字: "<<que[quef].pro_name<<" 提交时间: "<<que[quef].time_submit<<" 执行时间: "<<que[quef].time_exe<<" 开始时间: "<<que[quef].time_start<<" 结束时间: "<<que[quef].time_end<<"\n 周转时间: "<<que[quef].time_turn<<" 带权周转: "<<que[quef].time_aver<<endl ;quef++; //pcb出队列}}} // CPU模拟结束cout<<"\n所有进程运行完毕!"<<endl;double c=(time-freetime)/(double)time*100;cout<<"\ncpu利用率:"<<c<<"%"<<endl;}//主函数int main(){cout<<" *** 进程调度模拟程序***\n";cout<<"-----------------------------------------------------------\n";cout<<" *** 专业:计算机科学与技术软件工程20101122班***\n";cout<<" *** 学号:2010112241 ***\n";cout<<" *** 姓名: 张洪***\n";cout<<" *** 指导老师: 张莉莉***\n";cout<<"-----------------------------------------------------------\n";cout<<" \n";cout<<" \n";CpuModel cpu;cpu.cpurun();return 0;}........忽略此处.......。