进程模拟调度算法课程设计
操作系统课程设计报告-进程调度的模拟实现
操作系统课程设计报告专业计算机科学与技术学生姓名班级学号指导教师完成日期博雅学院ﻬ题目:进程调度的模拟实现的模拟实现一、设计目的本课程设计是学习完“操作系统原理”课程后进行的一次全面的综合训练,通过课程设计,更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解,加强学生的动手能力。
在多道程序和多任务系统中,系统内同时处于就绪状态的进程可能有若干个。
也就是说能运行的进程数大于处理机个数。
为了使系统中的进程能有条不紊地工作,必须选用某种调度策略,选择一进程占用处理机。
要求学生设计一个模拟处理机调度算法,以巩固和加深处理机调度的概念.二、设计内容1)概述选择一个调度算法,实现处理机调度。
设计要求:1)进程调度算法包括:时间片轮转法,短作业优先算法,动态优先级算法。
2)可选择进程数量3)本程序包括三种算法,用C或C++语言实现,执行时在主界面选择算法(可用函数实现),进入子页面后输入进程数,(运行时间,优先数由随机函数产生),执行,显示结果。
调度时总是选取优先数最大的进程优先运行2.每个进程的优先数,运行时间,由程序任意指定.3.为了调度方便,把进程按给定优先级(动态优先级算法中)从小到大排成一个队列。
按给定运行时间(短作业优先)从小到大排成一个队列用一个变量作为队首指针,指向队列的第一个进程。
4.处理机调度总是选队首进程运行。
由于本实验是模拟处理机调度,所以被选中的进程并不实际的启动运行,而是执行:优先数-1(动态优先级算法中)要求运行时间-1来模拟进程的一次运行。
5.进程运行一次后,若要求运行时间不等于0,则再将它加入队列(动态优先级算法中:按优先数大小插入.),且改变队首指针:若要求运行时间=0,则把它的状态改为完成(C)状态,且退出队列。
(5)对于遇到优先数一致的情况,采用FIFO策略解决.3。
概要设计(1)本程序用两种算法对五个进程进行调度,每个进程可有三个状态,并假设初始状态为就绪状态。
进程调度算法模拟 (操作系统课程设计报告)
福建农林大学计算机与信息学院课程设计报告课程名称:操作系统实习题目:进程调度算法模拟姓名:系:计算机科学与技术系专业:计算机科学与技术年级: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.03.3系统技术分析(1)编程实现对N个进程采用某种进程调度算法(如动态优先权调度算法、先来先服务算法、短进程优先算法、时间片轮转调度算法)调度执行的模拟。
(2)每个用来标识进程的进程控制块PCB可用结构来描述,包括以下字段:进程标识数ID。
操作系统进程调度模拟课程设计(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. 学生能运用进程调度算法解决实际问题,如进程优先级分配、CPU利用率优化等。
技能目标:1. 学生通过案例学习,培养分析问题、解决问题的能力,能设计简单的进程调度算法。
2. 学生能运用所学知识,对实际操作系统中的进程调度进行模拟和优化。
3. 学生能运用图表、流程图等工具,清晰、有条理地展示进程调度算法的过程。
情感态度价值观目标:1. 学生培养对计算机操作系统及进程调度算法的兴趣,激发探索计算机科学领域的热情。
2. 学生通过学习进程调度算法,认识到优化算法对提高计算机系统性能的重要性,增强社会责任感和创新意识。
3. 学生通过小组合作学习,培养团队协作精神,提高沟通、交流能力。
课程性质:本课程为计算机科学领域的基础课程,主要研究操作系统中进程调度算法的原理及其应用。
学生特点:学生已具备一定的计算机操作基础,对操作系统有初步了解,但进程调度算法较为抽象,需要结合实际案例进行讲解。
教学要求:结合实际案例,采用启发式教学,引导学生主动思考、探索和解决问题。
注重理论与实践相结合,培养学生的实际操作能力和创新意识。
通过小组合作、讨论等形式,提高学生的沟通能力和团队协作精神。
在教学过程中,关注学生的个体差异,因材施教,确保每个学生都能达到课程目标。
二、教学内容1. 进程调度算法概述:介绍进程调度算法的基本概念、目的和重要性。
- 理解进程与线程的区别,掌握进程调度的基本任务。
- 熟悉进程调度算法的分类,如先来先服务、短作业优先、优先级调度等。
2. 先来先服务调度算法(FCFS):分析算法原理、特点及优缺点。
- 学习FCFS算法的作业排序规则,分析其对作业执行时间的影响。
3. 短作业优先调度算法(SJF):介绍SJF算法的原理,比较其与FCFS算法的差异。
进程调度模拟程序课程设计
《操作系统》课程设计报告专业:计算机科学与技术班级:09计本班学号姓名成绩200981010118刘利刚题目名称:进程调度模拟程序完成日期:2012年6月20日甘肃政法学院计算机科学学院目录第一章课程设计目的 (3)第二章课程设计要求 (3)第三章设计思想 (5)3.1 基本概念 (5)3.2 进程控制块 (6)3.3 算法思想 (7)第四章详细设计 (8)4.1 程序设计流程图 (8)4.2 程序各模块功能介绍 (9)第五章运行结果及分析 (18)5.1 程序调试 (18)5.2 运行结果 (19)5.3 结果分析 (21)第六章总结 (22)参考文献 (22)进程调度模拟程序第一章课程设计目的深入掌握进程调度的概念原理和实现方法,理解操作系统进程管理中进行进程调度的过程和编程方法,掌握先来先服务调度算法和最高优先数优先的调度算法,创建进程控制块PCB。
理解进程的状态及变化,动态显示每个进程的当前状态及进程的调度情况。
进程调度是处理机管理的核心内容。
本次课程设计用C 语言编写模拟进程调度程序,以便加深理解有关进程控制快、进程队列等概念,并体会最高优先数优先与按时间片轮转调度结合算法的优缺点。
第二章课程设计要求编写一个进程调度程序,允许多个进程并行执行。
1、进程调度算法:采用最高优先数优先与按时间片轮转调度结合算法。
2、每个进程有一个进程控制块(PCB)表示。
进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
3、进程的优先数及需要的运行时间可在运行时输入,进程的到达时间为输入进程的时间。
4、进程的运行时间以时间片为单位进行计算。
5、每个进程的状态可以是就绪W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。
6、就绪进程获得CPU后都只能运行一个时间片。
7、如果运行一个时间片后,进程的已占用CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。
操作系统课程设计-进程调度算法模拟
操作系统课程设计----进程调度算法模拟一、实验内容:模拟五种进程调度算法并计算各参数值二、实验原理:(1)先来先服务调度:最先到达的进程先进行调度(2)短作业优先调度:从已到达的进程中选出最短的进程优先调度(3)时间片轮转调度:每个进程依次的按时间片轮流的方式执行(4)静态优先权调度:赋予优先权,在已到达的进程中选出优先权最高的优先调度(5)高响应比优先调度:优先权随等待时间而增加,从而使等待时间较长且服务时间较短的进程优先调度响应比=1+等待时间/服务时间三、实验设计说明:本程序采用C++ Builder 5编程和设计界面考虑到调度算法较多,采用了多页面的界面(如下图),加入的进程限制五个,在文本框中模拟到达一进程后,输入到达时间和服务时间,点击“加入新进程”即可,输入完成之后,点击运行即可得到表中各值。
想从新输入可点击“清除”按钮。
关闭时直接点击“×”即可。
该程序还不是很完善,有一些小问题,尚待解决,还得向老师请教。
四、实验结果:(只打印两个结果示范)运行后操作面板初始化如下图:短作业优先结果如图:时间片轮转结果如图:(书上的例题)五、实验源程序:Unit1.h文件//---------------------------------------------------------------------------#ifndef Unit1H#define Unit1H//---------------------------------------------------------------------------#include <Classes.hpp>#include <Controls.hpp>#include <StdCtrls.hpp>#include <Forms.hpp>#include <ComCtrls.hpp>#include <Grids.hpp>#include <ExtCtrls.hpp>//--------------------------------------------------------------------------- class TForm1 : public TForm{__published: // IDE-managed ComponentsTPageControl *PageControl1; TTabSheet *TabSheet1; TTabSheet *TabSheet2; TTabSheet *TabSheet3; TTabSheet *TabSheet4; TabSheet *TabSheet5; TStringGrid *sgr;TButton *Button1;TButton *Button2;TButton *Button3; TStringGrid *sgr1;TButton *Button4;TButton *Button5;TButton *Button6; TStringGrid *sgr2;TButton *Button7;TButton *Button8;TButton *Button9; TStringGrid *sgr3;TButton *Button10; TButton *Button11; TButton *Button12; TStringGrid *sgr4;TButton *Button13; TButton *Button14; TButton *Button15;TLabel *Label1;TEdit *Edit1;TLabel *Label2;TEdit *Edit2;TEdit *Edit3;TEdit *Edit4;TLabel *Label3;TLabel *Label4;TEdit *Edit5;TLabel *Label5;TLabel *Label6;TEdit *Edit6; TLabel *Label7;TEdit *Edit7;TLabel *Label8;TLabel *Label9;TLabel *Label10;TEdit *Edit8;TEdit *Edit9;TEdit *Edit10;TLabel *Label11;TLabel *Label12;TEdit *Edit11;TEdit *Edit12;void __fastcall FormCreate(TObject *Sender);void __fastcall Button3Click(TObject *Sender);void __fastcall Button1Click(TObject *Sender);void __fastcall Button2Click(TObject *Sender);void __fastcall Button6Click(TObject *Sender);void __fastcall Button5Click(TObject *Sender);void __fastcall Button4Click(TObject *Sender);void __fastcall Button9Click(TObject *Sender);void __fastcall Button7Click(TObject *Sender);void __fastcall Button8Click(TObject *Sender);void __fastcall Button12Click(TObject *Sender); void __fastcall Button10Click(TObject *Sender); void __fastcall Button11Click(TObject *Sender);void __fastcall Button15Click(TObject *Sender); void __fastcall Button13Click(TObject *Sender); void __fastcall Button14Click(TObject *Sender);private: // User declarationspublic: // User declarations__fastcall TForm1(TComponent* Owner);};//---------------------------------------------------------------------------extern PACKAGE TForm1 *Form1;//---------------------------------------------------------------------------#endif******************************************************************************* Unit1.cpp文件//--------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "Unit1.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;float super[6]; //优先权float come[6]; //到达时间float serve[6]; //服务时间float begin[6]; //开始执行时间float end[6]; //完成时间float all[6]; //周转时间float dall[6]; //带权周转时间float max(float,float,float);//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) //初始化表格: TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){sgr->Cells[0][0]="进程名";sgr1->Cells[0][0]="进程名";sgr2->Cells[0][0]="进程名";sgr3->Cells[0][0]="进程名";sgr4->Cells[0][0]="进程名";sgr3->Cells[0][1]="优先权";sgr->Cells[0][1]="到达时间";sgr1->Cells[0][1]="到达时间";sgr2->Cells[0][1]="到达时间";sgr3->Cells[0][2]="到达时间";sgr4->Cells[0][1]="到达时间";sgr->Cells[0][2]="服务时间";sgr1->Cells[0][2]="服务时间";sgr2->Cells[0][2]="服务时间";sgr3->Cells[0][3]="服务时间";sgr4->Cells[0][2]="服务时间";sgr->Cells[0][3]="开始执行时间";sgr1->Cells[0][3]="开始执行时间";sgr3->Cells[0][4]="开始执行时间";sgr4->Cells[0][3]="开始执行时间";sgr4->Cells[0][4]="等待时间";sgr4->Cells[0][5]="响应比";sgr->Cells[0][4]="完成时间";sgr1->Cells[0][4]="完成时间";sgr2->Cells[0][3]="完成时间";sgr3->Cells[0][5]="完成时间";sgr4->Cells[0][6]="完成时间";sgr->Cells[0][5]="周转时间";sgr1->Cells[0][5]="周转时间";sgr2->Cells[0][4]="周转时间";sgr3->Cells[0][6]="周转时间";sgr4->Cells[0][7]="周转时间";sgr->Cells[0][6]="带权周转时间";sgr1->Cells[0][6]="带权周转时间";sgr2->Cells[0][5]="带权周转时间";sgr3->Cells[0][7]="带权周转时间";sgr4->Cells[0][8]="带权周转时间";sgr->Cells[0][7]="显示调度结果";sgr1->Cells[0][7]="显示调度结果";sgr3->Cells[0][8]="显示调度结果";sgr4->Cells[0][9]="显示调度结果";}//---------------------------------------------------------------------------//先来先服务调度算法void __fastcall TForm1::Button3Click(TObject *Sender) //输入初值,5个{static int i=1;sgr->Cells[i][0]=i; //进程编号sgr->Cells[i][1]=Edit1->Text; //输入到达时间come[i]=StrToFloat(Edit1->Text); //赋到达时间给表格sgr->Cells[i][2]=Edit2->Text; //输入服务时间serve[i]=StrToFloat(Edit2->Text); // 赋服务时间给表格i++;if(i>5) i=1;}//---------------------------------------------------------------------------float max(float x,float y,float m) //定义函数{return (x+y)>m?(x+y):m;}//---------------------------------------------------------------------------//““运行”按键函数void __fastcall TForm1::Button1Click(TObject *Sender){int i=1;begin[1]=come[1];sgr->Cells[1][3]=begin[1]; //初始值for(i=2;i<=5;i++){begin[i]=max(serve[i-1],begin[i-1],come[i]); //调用函数sgr->Cells[i][3]=begin[i];} //开始执行时间for(i=1;i<=5;i++) //计算各个值{end[i]=begin[i]+serve[i];sgr->Cells[i][4]=end[i];all[i]=end[i]-come[i];sgr->Cells[i][5]=all[i];dall[i]=all[i]/serve[i];sgr->Cells[i][6]=dall[i];sgr->Cells[i][7]=i;}}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button2Click(TObject *Sender){ int i=0,j=0;for(i=0;i<=7;i++)for(j=1;j<=5;j++){sgr->Cells[j][i]="";}}//---------------------------------------------------------------------------//短作业优先调度函数//“加入新进程”输入初值void __fastcall TForm1::Button6Click(TObject *Sender){static int i=1;sgr1->Cells[i][0]=i; //进程编号sgr1->Cells[i][1]=Edit3->Text;come[i]=StrToFloat(Edit3->Text);sgr1->Cells[i][2]=Edit4->Text;serve[i]=StrToFloat(Edit4->Text);i++;if(i>5) i=1;}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button5Click(TObject *Sender){ int i=0,j=0;for(i=0;i<=7;i++)for(j=1;j<=5;j++){sgr1->Cells[j][i]="";}}//---------------------------------------------------------------------------//“运行”按钮函数void __fastcall TForm1::Button4Click(TObject *Sender){int i,j,k,run=1,index=1,flag[6]={1,1,1,1,1,1},t[4]; //flag用于设置访问值“1”为未访问sgr1->Cells[1][7]="1";begin[1]=come[1];sgr1->Cells[1][3]=FloatToStr(begin[1]);end[1]=begin[1]+serve[1];sgr1->Cells[1][4]=FloatToStr(end[1]);sgr1->Cells[1][5]=FloatToStr(end[1]-come[1]);sgr1->Cells[1][6]=FloatToStr((end[1]-come[1])/serve[1]); //初始化for(j=1;j<=4;j++){index++; //index自动指向下一个进程if (index>5) //index值的复位{for(k=2;k<=5;k++)if (flag[k]==1){index=k; //index指向第一个未执行的进程break;}}for(i=2;i<=5;i++)//满足三个条件的进程才可调度,1、已到达2、未调度过3、服务时间最小{ if ((come[i]<=end[run])&&(serve[index]>serve[i])&&(flag[i]==1)){index=i;}else if (come[i]>end[run]) //如果一进程完成未有进程到达,则下一个进程到来就直接调度break;}flag[index]=0;//处理index,index为当前运行的进程编号,run为上一个进程的编号begin[index]=max(serve[run],begin[run],come[index]); //开始执行时间sgr1->Cells[index][3]=FloatToStr(begin[index]);run=index;end[index]=begin[index]+serve[index]; //计算完成时间sgr1->Cells[index][4]=FloatToStr(end[index]);all[index]=end[index]-come[index]; //计算周转时间sgr1->Cells[index][5]=FloatToStr(all[index]);sgr1->Cells[index][6]=FloatToStr(all[index]/serve[index]); //赋带权周转时间t[j]=index; // t[j]为调度序列}for(i=1;i<=4;i++)sgr1->Cells[i+1][7]=FloatToStr(t[i]); //显示调度结果}//---------------------------------------------------------------------------//时间片轮转调度算法void __fastcall TForm1::Button9Click(TObject *Sender){static int i=1;sgr2->Cells[i][0]=i; //进程编号sgr2->Cells[i][1]=Edit5->Text;come[i]=StrToFloat(Edit5->Text);sgr2->Cells[i][2]=Edit6->Text;serve[i]=StrToFloat(Edit6->Text);i++;if(i>5) i=1;}//---------------------------------------------------------------------------//“运行”按钮函数void __fastcall TForm1::Button7Click(TObject *Sender){int i=1,j=1,flag[6]={1,1,1,1,1,1};float t=0,q,a[6]; // q为时间片大小q=StrToFloat(Edit7->Text); //赋值给qfor(i=1;i<=5;i++)a[i]=serve[i];for(j=1;j<=100;j++) //设总时间片不超过100{for(i=1;i<=5;i++){if(flag[i]==1){ serve[i]-=q; //计算服务时间if(serve[i]>0){t+=q; //t为当前执行的总时间}else if(serve[i]<=0){t+=(q+serve[i]); //t为当前执行的总时间end[i]=t; //进程调度完毕送完成时间flag[i]=0; //一旦进程被调度后置flag值为0}}}}for(i=1;i<=5;i++) //显示结果{sgr2->Cells[i][3]=FloatToStr(end[i]);all[i]=end[i]-come[i];sgr2->Cells[i][4]=FloatToStr(all[i]);sgr2->Cells[i][5]=FloatToStr(all[i]/a[i]);}}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button8Click(TObject *Sender){int i=0,j=0;for(i=0;i<=6;i++)for(j=1;j<=5;j++){sgr2->Cells[j][i]="";}}//---------------------------------------------------------------------------//优先权调度算法(原理类似短作业优先)//“加入新进程”输入初值void __fastcall TForm1::Button12Click(TObject *Sender){static int i=1;sgr3->Cells[i][0]=i; //进程编号sgr3->Cells[i][1]=Edit8->Text;super[i]=StrToFloat(Edit8->Text);sgr3->Cells[i][2]=Edit9->Text;come[i]=StrToFloat(Edit9->Text);sgr3->Cells[i][3]=Edit10->Text;serve[i]=StrToFloat(Edit10->Text);i++;if(i>5) i=1;}//---------------------------------------------------------------------------//“运行”按钮函数void __fastcall TForm1::Button10Click(TObject *Sender){int i,j,k,run=1,index=1,flag[6]={1,1,1,1,1,1},t[4]; //run为上一个调度的进程号sgr3->Cells[1][8]="1";begin[1]=come[1];sgr3->Cells[1][4]=FloatToStr(begin[1]);end[1]=begin[1]+serve[1];sgr3->Cells[1][5]=FloatToStr(end[1]);sgr3->Cells[1][6]=FloatToStr(end[1]-come[1]);sgr3->Cells[1][7]=FloatToStr((end[1]-come[1])/serve[1]);//初始化for(j=1;j<=4;j++){index++;while(flag[index]==0){index++;} //index指向下一个待运行的进程if (index>5) //index值的复位{for(k=2;k<=5;k++)if (flag[k]==1){index=k;break;}}for(i=2;i<=5;i++){ if ((come[i]<=end[run])&&(super[index]>super[i])&&(flag[i]==1)){index=i; //满足条件的进程号送给index}else if (come[i]>end[run])break;}flag[index]=0;//处理indexbegin[index]=max(serve[run],begin[run],come[index]);sgr3->Cells[index][4]=FloatToStr(begin[index]);run=index;end[index]=begin[index]+serve[index];sgr3->Cells[index][5]=FloatToStr(end[index]);all[index]=end[index]-come[index];sgr3->Cells[index][7]=FloatToStr(all[index]/serve[index]);t[j]=index;}for(i=1;i<=4;i++)sgr3->Cells[i+1][8]=FloatToStr(t[i]);}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button11Click(TObject *Sender){int i=0,j=0;for(i=0;i<=9;i++)for(j=1;j<=5;j++)sgr3->Cells[j][i]="";}//---------------------------------------------------------------------------//高响应比优先调度算法(类似优先权调度算法,响应比为动态的)//“清除”按键函数void __fastcall TForm1::Button15Click(TObject *Sender){static int i=1;sgr4->Cells[i][0]=i; //进程编号sgr4->Cells[i][1]=Edit11->Text;come[i]=StrToFloat(Edit11->Text);sgr4->Cells[i][2]=Edit12->Text;serve[i]=StrToFloat(Edit12->Text);i++;if(i>5) i=1;}//---------------------------------------------------------------------------//“运行”按钮函数void __fastcall TForm1::Button13Click(TObject *Sender){int i,j,k,run=1,index=1,flag[6]={1,1,1,1,1,1},t[4];float xy[6]; //xy[]为响应比数组sgr4->Cells[1][9]="1";begin[1]=come[1];sgr4->Cells[1][3]=FloatToStr(begin[1]);sgr4->Cells[1][4]="0";xy[1]=1+0;sgr4->Cells[1][5]=FloatToStr(xy[1]);end[1]=begin[1]+serve[1];sgr4->Cells[1][6]=FloatToStr(end[1]);sgr4->Cells[1][8]=FloatToStr((end[1]-come[1])/serve[1]); //初始化for(j=1;j<=4;j++){index++;if (index>5){for(k=2;k<=5;k++)if (flag[k]==1){index=k;break;}}for(i=2;i<=5;i++){ if ((come[i]<end[run])&&((end[run]-come[index])/serve[index]<(end[run]-come[index])/serve[i]) &&(flag[i]==1)) //动态计算响应比并比较{index=i;}else if (come[i]>end[run])break;}flag[index]=0;//处理indexbegin[index]=max(serve[run],begin[run],come[index]);sgr4->Cells[index][3]=FloatToStr(begin[index]);sgr4->Cells[index][4]=FloatToStr(end[run]-come[index]);xy[index]=1+(end[run]-come[index])/serve[index];sgr4->Cells[index][5]=FloatToStr(xy[index]);run=index;end[index]=begin[index]+serve[index];sgr4->Cells[index][6]=FloatToStr(end[index]);all[index]=end[index]-come[index];sgr4->Cells[index][7]=FloatToStr(all[index]);sgr4->Cells[index][8]=FloatToStr(all[index]/serve[index]);t[j]=index;}for(i=1;i<=4;i++)sgr4->Cells[i+1][9]=FloatToStr(t[i]);}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button14Click(TObject *Sender){int i=0,j=0;for(i=0;i<=9;i++)for(j=1;j<=5;j++)sgr4->Cells[j][i]="";}//---------------------------------------------------------------------------六、实验总结:此次实验花了一周多的时间完成了程序的编写和界面设计,这其中也走了不少弯路。
模拟进程管理课程设计
模拟进程管理课程设计一、课程目标知识目标:1. 学生能理解计算机操作系统中进程管理的基本概念,掌握进程的定义、状态及其转换过程。
2. 学生能描述进程调度算法的类型及其特点,解释不同调度算法对系统性能的影响。
3. 学生能解释进程同步与互斥的概念,并掌握基本的同步机制。
技能目标:1. 学生能够运用流程图或伪代码设计简单的进程管理策略。
2. 学生通过模拟实验,能够分析和评价不同进程调度算法的效果。
3. 学生能够通过小组合作,编写简单的进程同步程序,解决实际问题。
情感态度价值观目标:1. 学生通过本课程的学习,培养对计算机操作系统工作原理的兴趣,激发对信息技术领域的探索热情。
2. 学生在小组合作中,学会倾听、尊重他人意见,培养团队合作精神和解决问题的能力。
3. 学生能够认识到计算机科学技术对社会发展的重要性,增强对科技进步的敏感性和责任感。
课程性质分析:本课程为计算机科学领域的选修课程,旨在帮助学生深入理解计算机操作系统的核心概念,提高解决实际问题的能力。
学生特点分析:考虑到学生为高年级学生,具备一定的计算机操作基础和编程能力,对操作系统有一定了解,但需深化对进程管理的认识。
教学要求:结合学生特点和课程性质,课程目标设定既要注重理论知识的学习,也要关注实践技能的培养,同时关注学生情感态度价值观的塑造。
通过具体可衡量的学习成果,确保学生能够达到课程预期目标。
二、教学内容1. 进程管理基本概念:包括进程的定义、特征、状态及其转换,进程控制块的作用与内容。
2. 进程调度算法:研究进程调度的基本方法,如先来先服务(FCFS)、短作业优先(SJF)、优先级调度、时间片轮转等算法,分析各自优缺点。
3. 进程同步与互斥:介绍进程同步、互斥的概念,探讨同步机制如信号量、管程等,并分析经典同步问题,如生产者-消费者问题、读者-写者问题。
4. 进程通信:讲解进程间通信的方式,如消息传递、共享内存等,以及相关的通信协议。
5. 模拟实验:设计实验环节,让学生通过模拟软件或编程实践,加深对进程管理原理的理解。
操作系统课程设计进程调度模拟设计
课程设计课程名字系统软件开发实训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) 根据选择的调度算法计算平均周转时间和平均带权周转时间。
操作系统课程设计——进程调度模拟算法(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. 学生能理解进程模拟的基本概念,掌握进程的基本状态和转换条件。
2. 学生能够运用流程图、伪代码等方式描述进程的运行过程。
3. 学生了解操作系统中进程管理的基本原理,并能够解释进程调度、同步和互斥等相关知识。
技能目标:1. 学生能够运用所学知识,设计简单的进程模拟程序,实现进程的创建、运行和终止。
2. 学生通过实际操作,学会使用至少一种编程工具进行进程模拟,提高编程实践能力。
3. 学生能够分析并解决进程管理中可能出现的问题,如死锁、饥饿等。
情感态度价值观目标:1. 培养学生对计算机科学和操作系统的兴趣,激发他们探索未知、积极进取的精神。
2. 增强学生的团队合作意识,使他们学会在团队中沟通、协作,共同完成任务。
3. 培养学生严谨、务实的科学态度,让他们认识到进程管理在计算机系统中的重要性。
本课程针对年级学生的认知特点和学科要求,以实际操作为导向,注重理论与实践相结合。
通过本课程的学习,学生将掌握进程模拟的基本知识和技能,培养他们解决实际问题的能力,同时提升对计算机科学的兴趣和情感态度。
为实现课程目标,后续教学设计和评估将围绕具体学习成果展开,确保教学效果的达成。
二、教学内容本课程教学内容以《计算机操作系统》教材中进程管理章节为基础,涵盖以下要点:1. 进程基本概念:进程的定义、进程与程序的区别、进程的属性。
2. 进程状态及转换:运行、就绪、阻塞状态,状态转换条件。
3. 进程控制块(PCB):作用、内容、管理方式。
4. 进程调度:进程调度算法,如FCFS、SJF、优先级调度等。
5. 进程同步与互斥:同步机制、互斥概念、生产者-消费者问题、哲学家就餐问题。
6. 死锁与饥饿:死锁的定义、预防、避免、检测与解除;饥饿现象及其解决方案。
7. 进程通信:进程间通信方式,如管道、消息队列、共享内存等。
教学大纲安排如下:第一课时:进程基本概念、进程状态及转换。
第二课时:进程控制块、进程调度。
进程管理模拟课程设计
进程管理模拟课程设计一、课程目标知识目标:1. 理解进程管理的基本概念,掌握进程的定义、进程的状态以及进程控制块的作用;2. 掌握进程的创建、终止、同步和互斥等基本操作,了解进程调度算法及其特点;3. 了解操作系统中进程管理模块的设计原理,理解进程管理对系统性能的影响。
技能目标:1. 能够运用进程管理的基本理论,分析实际操作系统中的进程管理问题;2. 学会使用流程图、伪代码等方法描述进程的创建、同步和互斥过程;3. 能够设计简单的进程调度算法,并对不同算法进行性能分析。
情感态度价值观目标:1. 培养学生对操作系统学科的兴趣,激发他们探究进程管理技术的热情;2. 培养学生的团队合作精神,使他们能够在学习过程中互相帮助、共同进步;3. 增强学生的信息安全意识,使他们认识到进程管理在操作系统安全中的重要性。
本课程针对高年级学生,课程性质为理论性与实践性相结合。
在分析课程性质、学生特点和教学要求的基础上,将课程目标分解为具体的学习成果,以便于后续的教学设计和评估。
通过本课程的学习,学生能够掌握进程管理的基本理论,具备一定的进程管理实践能力,并培养积极的情感态度价值观。
二、教学内容1. 进程管理概述- 进程与线程的概念及其区别- 进程的创建、终止和状态转换- 进程控制块的作用和结构2. 进程同步与互斥- 进程同步的基本概念- 互斥锁、信号量、管程等同步机制- 生产者-消费者问题、哲学家就餐问题等经典同步问题3. 进程调度- 进程调度算法:FCFS、SJF、RR、优先级调度等- 调度算法的性能比较和分析- 多级反馈队列调度算法原理4. 死锁与饥饿- 死锁的定义、产生原因及预防、避免、检测和解除方法- 饥饿的原因和解决方案5. 操作系统进程管理案例分析- 分析具体操作系统(如Linux)的进程管理模块- 进程管理在实际操作系统中的应用教学内容按照教学大纲安排,与课本章节相对应,确保科学性和系统性。
在教学过程中,教师将根据学生的实际情况,适时调整教学内容和进度,保证学生能够扎实掌握进程管理的基本理论和实践技能。
进程模拟调度算法课程设计
一.课程概述.设计构想程序能够完成以下操作:创建进程:先输入进程的数目,再一次输入每个进程的进程名、运行总时间和优先级,先到达的先输入;进程调度:进程创建完成后就选择进程调度算法,并单步执行,每次执行的结果都从屏幕上输出来。
.需求分析在多道程序环境下,主存中有着多个进程,其数目往往多于处理机数目,要使这多个进程能够并发地执行,这就要求系统能按某种算法,动态地把处理机分配给就绪队列中的一个进程,使之执行。
分配处理机的任务是由处理机调度程序完成的。
由于处理机是最重要的计算机资源,提高处理机的利用率及改善系统必(吞吐量、响应时间),在很大程度上取决于处理机调度性能的好坏,因而,处理机调度便成为操作系统设计的中心问题之一。
本次实验在VC++环境下实现先来先服务调度算法,短作业优先调度算法,高优先权调度算法,时间片轮转调度算法和多级反馈队列调度算法。
.理论依据为了描述和管制进程的运行,系统为每个进程定义了一个数据结构——进程控制块PCB(Process Control Block),PCB中记录了操作系统所需的、用于描述进程的当前情况以及控制进程运行的全部信息,系统总是通过PCB对进程进行控制,亦即,系统是根据进程的PCB 而不是任何别的什么而感知进程的存在的,PCB是进程存在的惟一标志。
本次课程设计用结构体Process代替PCB的功能。
.课程任务一、用C语言(或C++)编程实现操作模拟操作系统进程调度子系统的基本功能;运用多种算法实现对进程的模拟调度。
二、通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转、短作业优先、多级反馈队列调度算法,使学生进一步掌握进程调度的概念和算法,加深对处理机分配的理解。
三、实现用户界面的开发.功能模块分析:1、进程概念:进程是被独立分配资源的最小单位。
进程是动态概念,必须程序运行才有进程的产生。
2、进程的状态模型:(1)运行:进程已获得处理机,当前处于运行状态。
模拟进程调度功能的设计与实现操作系统课程设计(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。
操作系统课程设计-进程调度的模拟实现
课程设计题目进程调度算法模拟编程学生姓名学号专业计算机科学与技术班级指导教师完成日期2012年12月18日进程调度的模拟实现摘要:进程管理是操作系统中的重要功能,用来创建进程、撤消进程、实现进程状态转换,它提供了在可运行的进程之间复用CPU的方法。
在进程管理中,进程调度是核心,因为在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态,当就绪进程个数大于处理器数目时,就必须依照某种策略决定哪些进程优先占用处理器。
本文通过两种算法模拟实现了进程之间的调度。
关键词:进程创建,先来先服务,优先级调度。
一.前言在操作系统中,调度的实质是一种资源分配,调度算法即指:根据系统的资源分配策略所规定的资源分配算法。
对于不同的系统和系统目标,通常采用不同的调度算法,如在批处理系统中,为照顾为数众多的短作业,采用短作业有限调度算法;在分时系统中,为保证系统具有合理的响应时间,采用轮转法进行调度。
采用算法时,则要考虑多方面因素,以便达到最佳效果。
做好这个课程设计,有利于加深对操作系统进程调度知识的理解。
二. 系统总体框架设计本程序采用两种算法(最高优先级数优先的调度算法和先来先服务算法)对多个进程进行调度,每个进程有三个状态,初始状态为就绪状态。
最高优先级数优先的调度算法中,程序的某进程运行时间以时间片为单位计算。
各进程的优先数或轮转时间数以及进程需运行的时间片数的初始值均由用户给定。
在优先级数优先的调度算法中,优先级数的值设计为100与运行时间的差值,即Pro_time-process->needtime。
进程每执行一次,优先数减3,CPU 时间片数加1,进程还需要的时间片数减1。
对于遇到优先数一致的情况,采用先来先服务策略解决。
程序设计组成框图程序流程图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.输入进程数,各进程属性:关于提交时间执行时间等,将检测输入是否数字,不是数字即退出程序。
进程调度算法课程设计
信息与计算科学操作系统原理课程设计报告题目:进程调度算法班级:姓名:专业:进程调度算法一、实验目的通过优先权法与轮转调度算法的模拟加深对进程概念和进程调度过程的理解,掌握进程状态之间的切换,同时掌握进程调度算法的实现方法和技巧。
二、实验内容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)进程每运行一个时间片,优先数增加1.4、在调度前,系统中拥有的进程数PCB_number有键盘输入,进初始化后,所有的进程控制块PCB连接成就绪队列。
5、为了清楚的观察诸进程的调度过程,程序应将每个时间片内的进程的情况显示出来。
三、实验步骤1、进程管理程序调式好后,运行进程管理程序YNNYYNNYYN NY 2、优先权调度(1)输入1选择优先权调度算法模拟。
(2)输入开始进程个数n ,创建n 个PCB 并加入就绪队列ready_queue 中。
(3)就绪队列ready_queue 不为空,调度就绪队列中第一个进程运行,否则,从闲逛队列idleprocess 中调度闲逛进程运行。
(4)在运行过程中,当遇到阻塞,则该进程插入到阻塞队列block_queue 中,且将该进程从ready_queue 中删除。
进程模拟调度算法课程设计
一.课程概述1.1.设计构想程序能够完成以下操作:创建进程:先输入进程的数目,再一次输入每个进程的进程名、运行总时间和优先级,先到达的先输入;进程调度:进程创建完成后就选择进程调度算法,并单步执行,每次执行的结果都从屏幕上输出来。
1.2.需求分析在多道程序环境下,主存中有着多个进程,其数目往往多于处理机数目,要使这多个进程能够并发地执行,这就要求系统能按某种算法,动态地把处理机分配给就绪队列中的一个进程,使之执行。
分配处理机的任务是由处理机调度程序完成的。
由于处理机是最重要的计算机资源,提高处理机的利用率及改善系统必(吞吐量、响应时间),在很大程度上取决于处理机调度性能的好坏,因而,处理机调度便成为操作系统设计的中心问题之一。
本次实验在VC++6.0环境下实现先来先服务调度算法,短作业优先调度算法,高优先权调度算法,时间片轮转调度算法和多级反馈队列调度算法。
1.3.理论依据为了描述和管制进程的运行,系统为每个进程定义了一个数据结构——进程控制块PCB(Process Control Block),PCB中记录了操作系统所需的、用于描述进程的当前情况以及控制进程运行的全部信息,系统总是通过PCB对进程进行控制,亦即,系统是根据进程的PCB而不是任何别的什么而感知进程的存在的,PCB是进程存在的惟一标志。
本次课程设计用结构体Process代替PCB的功能。
1.4.课程任务一、用C语言(或C++)编程实现操作模拟操作系统进程调度子系统的基本功能;运用多种算法实现对进程的模拟调度。
二、通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转、短作业优先、多级反馈队列调度算法,使学生进一步掌握进程调度的概念和算法,加深对处理机分配的理解。
三、实现用户界面的开发1.5.功能模块分析:1、进程概念:进程是被独立分配资源的最小单位。
进程是动态概念,必须程序运行才有进程的产生。
2、进程的状态模型:(1)运行:进程已获得处理机,当前处于运行状态。
CPU调度算法的模拟实现课程设计
设计 1 CPU 调度算法的模拟实现一、设计目的1、深入理解CPU调度的四种算法:先到先服务算法FCFS、非抢占最短作业优先算法SJF、可抢占优先权调度算法PRIOR、时间片轮转算法RRO2、利用程序设计语言编写算法,模拟实现先到先服务算法FCFS、非抢占最短作业优先算法SJF、可抢占优先权调度算法PRIOR、时间片轮转算法RR O3、针对模拟进程,利用CPU调度算法进行调度。
4、进行算法评价,计算平均周转时间和平均等待时间。
二、设计要求1、调度所需的进程参数由输入产生:采用手工输入参数或产生随机数的方法。
2、针对各个进程模拟算法,输出进程调度结果,包括执行算法的等待时间和周转时间。
3、根据调度结果对算法进行调试分析,纠正程序错误并对算法进行优化,总结并输出算法评价指标。
三、设计说明(含系统框图和(或)主要算法的流程图)(1)优先权调度#include "stdio.h"#include "stdlib.h"#define N 10//#define M 10typedef struct{int m;//int flag;int priority;// 优先级顺序float zhixing;float zhouzhuan;float dq_zhouzhuan;}process;//int flag=0;// 标志已经执行个进程的个数//float time=0;// 当前共执行的时间void main(){//int plag=0;float time=0;int n;int i,j,temp;process fcfs[N],*p[N],*q;float time_zhouzhuan=0,wtime_zhouzhuan=0;//输入printf(" 请输入进程的个数:");scanf("%d",&n);for(i=0;i<n;i++){fcfs[i].m=i+1;//fcfs[i].linshi=0;//fcfs[i].flag=0;Printf("请输入进程%d所需的执行时间和进程的优先级:",fcfs[i].m); scanf("%f %d",&fcfs[i].zhixing,&fcfs[i].priority);}Printf("haha");for(i=0;i<n;i++){p[i]=(process*)malloc(sizeof(process));//分配空间P[i]=&fcfs[i];}//按优先级别的排序for(j=0;j<n-1;j++){printf("ok");// 有问题temp=j;for(i=j+1;i<n;i++){printf("ky");if(p[i]->priority>p[temp]->priority)temp=i;}printf("#####");q=p[j];// 交换p[j]=p[temp];p[temp]=q;}printf("he");//优先级算法for(i=0;i<n;i++){ time+=p[i]->zhixing;p[i]->zhouzhuan=time; p[i]->dq_zhouzhuan=p[i]->zhouzhuan/p[i]->zhixing; }for(i=0;i<n;i++){time_zhouzhuan+=p[i]->zhouzhuan; wtime_zhouzhuan+=p[i]->dq_zhouzhuan;} time_zhouzhuan/=n;wtime_zhouzhuan/=n;//输出结果Printf("静态优先级算法的进程的执行顺序为:∖n");for(i=0;i<n;i++){Printf("%d ",P[i]->m);}Printf("∖n 平均周转时间为%f",time_zhouzhuan);Printf("∖n 带权平均周转时间为%f",wtime_zhouzhuan);} (2) FCFS 和SJF 综合#include "stdio.h"#define getjcb(tyPe) (tyPe*)malloc(sizeof(tyPe))#define NULL 0/* 作业 名 *//* 作 业状态 *//* 提交 时间 *//* 优先权 *//* 开始运 行时间 *//* 完成 时间 */ /* 周转时间 */ /* 带权周 转时间 */ /* 作业所需 运行时间 */ char resource[10]; /* 所需 资源 */struct jcb *link; /* 结构体指 针 */ } *p,*q,*head=NULL;typedef struct jcb JCB; inital(){ int i;printf("\nInput jcb num\n"); scanf("%d",&n);printf("Input\nname\tts\tntime\tresource\n"); for(i=0;i<n;i++){p=getjcb(JCB);scanf("%s\t%d\t%d\t%s",&p->name,&p->ts,&p->ntime,&p->resource);p->state='W';p->link=NULL;if(head==NULL) head=q=p;else{q->link=p;q=p; } }}fileinput(){int n=0,time=0;floateti,ewi; struct jcb{ charname[10]; char state; int ts; float super; int tb;int tc;float ti;float wi;int ntime;FILE *fp; int i;if((fp=fopen("os2.txt","r"))==NULL) printf(" open error!") ;fscanf(fp,"%d\n",&n);for(i=0;i<n;i++){p=getjcb(JCB); scanf(fp,"%s%d%d%s",&p->name,&p->ts,&p->ntime,&p->resource); p->state='W';p->link=NULL;if(head==NULL) head=q=p;else{q->link=p; q=p;}}fclose(fp);}void print(JCB *pr,int m){JCB *p;printf("\ntime=%d",time);if(m==3){printf("\nname\tstate\tts\tntime\tsuper\tsource\ttb\ttc\tti\twi\n");printf("%s\t%c\t%d\t%d\t%4.2f\t%s\t%d\t%d\t%4.2f\t%4.2f\n",pr->name,pr->state,pr->ts,pr->ntime,pr->super,pr->resource,pr->tb,pr->tc,pr->ti, pr->w i); }else { printf("\nname\tstate\tts\tntime\tsource\ttb\ttc\tti\twi\n");printf("%s\t%c\t%d\t%d\t%s\t%d\t%d\t%4.2f\t%4.2f\n",pr->name,pr->state,pr->ts,pr->ntime,pr->resource,pr->tb,pr->tc,pr->ti,pr->wi); }p=head;do{ if(p->state=='W')if(m==3){ printf("%s\t%c\t%d\t%d\t%4.2f\t%s\n",p->name,p->state,p->ts,p->ntime,p->super,p->resource);}else{printf("%s\t%c\t%d\t%d\t%s\n",p->name,p->state,p->ts,p->ntime,p->resource); } p=p->link;}while(p!=NULL);p=head;do{if(p->state=='F') if(m==3){printf("%s\t%c\t%d\t%d\t%4.2f\t%s\t%d\t%d\t%4.2f\t%4.2f\n",p->name,p->state,p->ts,p->ntime,p->super,p->resource,p->tb,p->tc,p->ti,p->wi);} else{printf("%s\t%c\t%d\t%d\t%s\t%d\t%d\t%4.2f\t%4.2f\n",p->name,p->state,p->ts,p->ntime,p->resource,p->tb,p->tc,p->ti,p->wi); }p=p->link;}while(p!=NULL);} void last(){eti/=n;ewi/=n;printf("\neti=%7.3f\tewi=%7.3f\n",eti,ewi);}super(){JCB *padv; padv=head; do{if(padv->state=='W'&&padv->ts<=time)padv->super=(float)(time-padv->ts+padv->ntime)/padv->ntime; padv=padv->link;}while(padv!=NULL);}void hrn(m){JCB *min;int i,iden;for(i=0;i<n;i++){p=min=head;iden=1;super();do{if(p->state=='W'&&p->ts<=time)if(iden){min=p;iden=0;}else if(p->super>min->super) min=p;p=p->link;}while(p!=NULL);if(iden) {i--;time++;printf("\ntime=%d:\tno JCB submib...wait...",time);if(time>1000){printf("\nruntime is toolong...error...");getch();}}else{running(min,m);}}}void sjf(int m){JCB *min;int i,iden;for(i=0;i<n;i++){p=min=head;iden=1;do{ if(p->state=='W'&&p->ts<=time)if(iden){min=p;iden=0;}else if(p->ntime<min->ntime) min=p;p=p->link;}while(p!=NULL) ;if(iden) {i--;printf("\ntime=%d:\tno JCBsubmib...wait...",time);time++;if(time>100){printf("\nruntime is too long...error");getch();}} else{running(min,m);}}}fcfs(int m){int i,iden;printf("\n\nthe jcb is runing...");for(i=0;i<n;i++){p=head;iden=1;do{ if(p->state=='W'&&p->ts<=time) iden=0;if(iden)p=p->link;}while(p!=NULL&&iden) ;if(iden) {i--;printf("\ntime=%d:\tno JCB submib...wait...",time);time++;if(time>100){printf("\nruntime is too long...error");getch();}} else{ running(p,m);}}}running(JCB *p,int m){p->tb=time;p->state='R';p->tc=p->tb+p->ntime;p->ti=(float)(p->tc-p->ts);p->wi=(float)(p->ti/p->ntime);eti+=p->ti;ewi+=p->wi;print(p,m);time+=p->ntime;p->state='F';printf("\n%s has been finished!\npress any keyto continue...\n",p->name);getch();}void runjcb(int m){printf("\n\nstart running jcb...");switch(m){case 1:fcfs(m);break;case 2:sjf(m);break;case 3:hrn(m);break;default:printf("\nrunjcb error...\n");exit();}}fileway(){printf("\nadopts the file way to input the datas...y/n:") ;if(getch()=='y') fileinput(); else inital();} start(){int m;char str[100]="\nselect algorithm\n1.FCFS\n2.SJF\n3.HRN\n" ;printf("%s",str);m=getch()-48; fileway();if(1<=m&&m<=3) runjcb(m);else {printf("\nselect error!try again...\n");start();} last();}void main(){ start();printf("\nfinished!");getch();}(3)RR 算法#include<stdio.h> #include<stdlib.h> #include<conio.h> #include<iostream> using namespace std;#define getch(type)(type*)malloc(sizeof(type))#define null 0#define MAXN 1000int stack[MAXN];int top;StruCtPcb{∕/调用进程模块Char name[10];//进程名char State; /进/ 程状态:就绪,运行,完成int super; //进程优先级int ntime;// 需要运行的时间int rtime;// 到达时间changestruct pcb* link;// 链接指针}*ready=null,*p;typedef struct pcb PCB;void destroy();void check();VOid SOrtO//建立对进程优先级排列函数{PCB *first,*secOnd;int insert = 0;if( ( ready == null ) || ( ( p -> rtime ) < ( ready -> rtime ) ) ){// 优先级最大者,插入队首p -> link = ready;ready = p;}else {//进程比较优先级。
《高级语言程序设计》课程设计--进程调度模拟
《高级语言程序设计》课程设计报告题目:进程调度模拟目录1 1 设计目的及要求 (3)1.1 设计目的 (3)1.2 课程设计的实验环境 (3)1.3 课程设计的预备知识 (3)1.4 课程设计要求 (3)2 课程设计内容 (3)2.1程序功能介绍 (3)2.2程序整体设计说明 (4)2.2.1设计思路 (4)2.2.2数据结构设计及用法说明 (5)2.2.3程序结构(流程图) (5)2.2.4各模块的功能及程序说明 (6)2.2.5程序运行结果 (7)3 总结 (9)参考资料 (11)程序源代码 (12)1 设计目的及要求1.1 设计目的本课程设计是计算机科学与技术专业重要的实践性环节之一,是在学生学习完《程序设计语言(C)》课程后进行的一次全面的综合练习。
本课程设计的目的和任务:1. 巩固和加深学生对C语言课程的基本知识的理解和掌握2. 掌握C语言编程和程序调试的基本技能3. 利用C语言进行基本的软件设计4. 掌握书写程序设计说明文档的能力5. 提高运用C语言解决实际问题的能力1.2 课程设计的实验环境硬件要求能运行Windows 2000/XP操作系统的微机系统。
C语言程序设计及相应的开发环境。
1.3 课程设计的预备知识熟悉C语言及C语言开发工具。
1.4 课程设计要求1. 分析课程设计题目的要求2. 写出详细设计说明3. 编写程序代码,调试程序使其能正确运行4. 设计完成的软件要便于操作和使用5. 设计完成后提交课程设计报告2课程设计内容2.1程序功能介绍在多道程序环境下,进程数目往往多于处理机数目,致使他们争用处理机。
这就要求系统能按某种算法,动态地把处理机分配给就绪队列中的一个进程,使之运行。
分配处理机的任务是由进程调度程序完成的。
一个进程被建立后,系统为了便于对进程进行管理,将系统中的所有进程按其状态,将其组织成不同点进程队列。
于是系统中有运行进程队列、就绪队列和各种事件的进程等待队列。
设计1 进程调度算法的模拟
设计1 进程调度算法的模拟一、设计目的1、通过编程实现进程调度算法的模拟,了解进程调度的过程,理解进程调度各方法的特点。
二、设计要求1.用语言来实现对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链接成就绪队列。
三、设计说明1 FCFS模块1.1 功能对于先到达的进程优先分配CPU,按照先来先服务的原则依次执行各进程。
1.2 数据结构typedef struct PCB{int ID; //进程优先数,用于标示不同的进程int Priority; //进程优先级int CPUTime; //进程占用的CPU时间CPUtime,进程每运行一次,累计值等于4int ALLTime; //进程总共需要运行时间Alltimeint Status; //用于表示进程状态,0:就绪态;1:运行态;2:阻塞态}PCB;1.3算法void FCFS(){Node *p=head->next;while(p!=NULL){cout<<"执行进程"<<endl<<p->data.ID;p=p->next;}cout<<endl;cout<<"所有进程都执行完成"<<endl;}2.SJF模块2.1功能先找到运行时间最短的程序,然后执行,再从剩余的程序中找到运行时间最短的在执行,依次每次都执行运行时间最短的,直到程序执行完毕。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
一.课程概述1.1.设计构想程序能够完成以下操作:创建进程:先输入进程的数目,再一次输入每个进程的进程名、运行总时间和优先级,先到达的先输入;进程调度:进程创建完成后就选择进程调度算法,并单步执行,每次执行的结果都从屏幕上输出来。
1.2.需求分析在多道程序环境下,主存中有着多个进程,其数目往往多于处理机数目,要使这多个进程能够并发地执行,这就要求系统能按某种算法,动态地把处理机分配给就绪队列中的一个进程,使之执行。
分配处理机的任务是由处理机调度程序完成的。
由于处理机是最重要的计算机资源,提高处理机的利用率及改善系统必(吞吐量、响应时间),在很大程度上取决于处理机调度性能的好坏,因而,处理机调度便成为操作系统设计的中心问题之一。
本次实验在VC++6.0环境下实现先来先服务调度算法,短作业优先调度算法,高优先权调度算法,时间片轮转调度算法和多级反馈队列调度算法。
1.3.理论依据为了描述和管制进程的运行,系统为每个进程定义了一个数据结构——进程控制块PCB(Process Control Block),PCB中记录了操作系统所需的、用于描述进程的当前情况以及控制进程运行的全部信息,系统总是通过PCB对进程进行控制,亦即,系统是根据进程的PCB 而不是任何别的什么而感知进程的存在的,PCB是进程存在的惟一标志。
本次课程设计用结构体Process代替PCB的功能。
1.4.课程任务一、用C语言(或C++)编程实现操作模拟操作系统进程调度子系统的基本功能;运用多种算法实现对进程的模拟调度。
二、通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转、短作业优先、多级反馈队列调度算法,使学生进一步掌握进程调度的概念和算法,加深对处理机分配的理解。
三、实现用户界面的开发1.5.功能模块分析:1、进程概念:进程是被独立分配资源的最小单位。
进程是动态概念,必须程序运行才有进程的产生。
2、进程的状态模型:(1)运行:进程已获得处理机,当前处于运行状态。
(2)就绪:进程已经准备好,一旦有处理器就可运行。
3、处理机调度:在多道程序设计系统中,内存中有多道程序运行,他们相互争夺处理机这一重要的资源。
处理机调度就是从就绪队列中,按照一定的算法选择一个进程并将处理机分配给它运行,以实现进程并发地执行。
4、进程调度算法的功能:记录系统中所有进程的执行情况选择占有处理机的进程进行进程的上下文切换5、进程调度的算法:(1)先来先服务算法:如果早就绪的进程排在就绪队列的前面,迟就绪的进程排在就绪队列的后面,那么先来先服务总是把当前处于就绪队列之首的那个进程调度到运行状态。
(2)优先数算法:即进程的执行顺序由高优先级到低优先级。
系统或用户按某种原则为进程指定一个优先级来表示该进程所享有的确调度优先权。
该算法核心是确定进程的优先级。
(3)时间片轮转算法:固定时间片,每个进程在执行一个时间片后,轮到下一进程执行,知道所有的进程执行完毕。
处理器同一个时间只能处理一个任务。
处理器在处理多任务的时候,就要看请求的时间顺序,如果时间一致,就要进行预测。
挑到一个任务后,需要若干步骤才能做完,这些步骤中有些需要处理器参与,有些不需要(如磁盘控制器的存储过程)。
不需要处理器处理的时候,这部分时间就要分配给其他的进程。
原来的进程就要处于等待的时间段上。
经过周密分配时间,宏观上就象是多个任务一起运行一样,但微观上是有先后的,就是时间片轮换。
(4) 多级反馈队列法:又称反馈循环队列或多队列策略,主要思想是将就绪进程分为两级或多级,系统相应建立两个或多个就绪进程队列,较高优先级的队列一般分配给较短的时间片。
处理器调度先从高级就绪进程队列中选取可占有处理器的进程,只有在选不到时,才从较低级的就绪进程队列中选取。
(5)短作业优先法:对短进程优先调度的算法,它是从后备队列中选择一个或者若干个进程,将处理机分配给它,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机时再重新调度。
二.设计方案2.1.先来先服务调度2.1.1.算法思想先来先服务调度算法的思想是按照进程进入就绪队列的先后顺序调度并分配处理机执行。
先来先服务调度算法是一种不可抢占的算法,先进入就绪队列的进程,先被处理机运行。
一旦一个进程占有了处理机,它就一直运行下去,直到该进程完成工作或者因为等待某事件而不能继续运行时才释放处理机。
2.1.2.算法流程图图1.先来先服务算法流程图2.1.3.程序代码#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct node{char name[10]; /*进程名*/int cputime; /*占用cpu时间*/char starttime[5]; //进程开始时间int needtime; /*要求运行时间*/char state; /*状态*/struct node *next; /*指针*/}PCB;PCB *ready, *run, *finish; //就绪、执行、结束指针int N; //进程数量void print() //输出函数{PCB *p;printf(" NAME CPUTIME STARTTIME NEEDTIME STATUS\n");if(run != NULL)printf(" %-10s%-10d%-10s%-10d %c\n",run->name,run->cputime,run->starttime,run->needtime,run->state); /*输出执行的进程的信息*/p=ready;while(p != NULL){printf(" %-10s%-10d%-10s%-10d %c\n",p->name,p->cputime,p->starttime,p->needtime,p->state); /*输出就绪进程的信息*/p=p->next;}p=finish;while(p != NULL){printf(" %-10s%-10d%-10s%-10d %c\n",p->name,p->cputime,p->starttime,p->needtime,p->state); /*输出结束队列的信息*/p=p->next;}getchar(); /*使用getchar()函数可以让输出时停留画面,等待人按回车继续*/}void insert(PCB *q) /*插入新进程,把进程按进程到来时间大小排序*/{PCB *p1,*s,*r;int b;s=q; /*指针s指向新要插入的进程*/p1=ready; /*指针p1指向原来的进程队列的队首*/r=p1; /*使用指针r是指向p1前面的进程*/b=1;while((p1!=NULL)&&b)if(strcmp(p1->starttime,s->starttime)<0){r=p1; p1=p1->next;} /*新进程的开始时间大,则p1 指向下一个进程继续比*/elseb=0;if(r!=p1){r->next=s; s->next=p1;} /*新进程找到位置,插在r和p1之间*/else{s->next=p1; ready=s;} /*新进程的开始时间按最小,插在队首,并修改就绪队首ready指针*/ }void create(){PCB *p;int i;ready=NULL;run=NULL;finish=NULL;printf("Please enter the name and time and starttime of PCB:\n");/*输入进程名、运行时间和开始时间*/for(i=0;i<N;i++){p=(PCB *)malloc(sizeof(PCB)); /*为新进程开辟空间*/scanf("%s",p->name); /*输入进程名*/scanf("%d",&p->needtime); /*输入进程要求运行时间*/scanf("%s",p->starttime); //输入进程开始时间p->cputime=0;p->state='W'; /*表示就绪队列中未在队首先执行,但也是就绪状态*/if (ready!=NULL)insert(p); /*就绪队首不为NULL,插入新进程*/else{ /*否则先插在NULL前*/p->next=ready;ready=p;}}printf(" Display is going to start: \n");printf("***********************************************\n");print();getchar();run=ready; /*队列排好,run指向就绪队列队首*/ready=ready->next; /*ready指向下一个进程*/run->state='R'; /*队首进程的状态为就绪*/}void FCFS(){while(run != NULL){run->cputime=run->cputime+run->needtime;run->needtime=0;run->next=finish;finish = run;run->state='E';run = NULL;if(ready != NULL){run = ready;run->state='R';ready=ready->next;}print();}}void main(){printf("Please enter the total number of PCB:\n");scanf("%d",&N);create(); /*模拟创建进程,并输入相关信息*/FCFS(); /*先来先服务调度算法*/}2.1.4.测试结果及说明首先输入进程个数(为5个),这里命名为A,B,C,D,E,然后分别输入运行时间和开始时间所有进程都在队列中,并都处于等待状态其中一个进程执行完毕所有进程都执行完毕2.2.优先级调度2.2.1.算法思想进程的执行顺序由高优先级到低优先级,系统或用户按某种原则为进程指定一个优先级来表示该进程所享有的确调度优先权。