进程模拟调度算法课程设计

合集下载

操作系统课程设计报告-进程调度的模拟实现

操作系统课程设计报告-进程调度的模拟实现

操作系统课程设计报告专业计算机科学与技术学生姓名班级学号指导教师完成日期博雅学院ﻬ题目:进程调度的模拟实现的模拟实现一、设计目的本课程设计是学习完“操作系统原理”课程后进行的一次全面的综合训练,通过课程设计,更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解,加强学生的动手能力。

在多道程序和多任务系统中,系统内同时处于就绪状态的进程可能有若干个。

也就是说能运行的进程数大于处理机个数。

为了使系统中的进程能有条不紊地工作,必须选用某种调度策略,选择一进程占用处理机。

要求学生设计一个模拟处理机调度算法,以巩固和加深处理机调度的概念.二、设计内容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。

操作系统课程设计报告-进程调度算法模拟

操作系统课程设计报告-进程调度算法模拟

1.课程设计的目的《操作系统原理》课程设计我们专业实践性环节之一,是学习完《操作系统原理》课程后进行的一次较全面的综合练习。

其目的在于加深对操作系统的理论、方法和基础知识的理解,掌握操作系统结构、实现机理和各种典型算法,系统地了解操作系统的设计和实现思路,培养学生的系统设计能力,并了解操作系统的发展动向和趋势。

2.课程设计的内容及要求先来先服务、短作业优先、时间片轮转、基于静态优先级的调度,基于高响应比优先的动态优先级调度算法实现,能够输出调度情况,并计算周转时间和平均周转时间。

要求使用链表,进程个数由用户提供,按照进程的实际个数生成PCB,程序能够让用户选择使用哪种调度算法,能够在Linux环境运行并验证结果。

程序要考虑用户界面的友好性和使用方便性。

进程基本信息可从文件读入,也可手动输入。

3、设计原理3.1先来先服务调度算法每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业,将它们调入内存,为它们分配资源创建进程,然后放入就绪队列3.2短作业优先调度算法短作业优先调度算法是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机时再重新调度。

3.3时间片轮转调度算法系统将所有的就绪进程按先来先服务的原则排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片。

时间片的大小从几ms到几百ms。

当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。

3.4静态优先级调度算法把处理机分配给优先级最高的进程,使之执行。

但在其执行期间,只要出现了另一个比其优先级更高的进程,调度程序就将处理机分配给新到的优先级最高的进程。

这样就可以保证紧迫性作业优先运行。

3.5最高响应比优先的动态优先级调度算法优先权调度算法是为了照顾紧迫型作业,使之在进入系统后便获得优先处理,引入最高优先权优先调度算法。

操作系统进程调度模拟课程设计(java)

操作系统进程调度模拟课程设计(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操作系统之上。

操作系统课程设计报告进程调度算法

操作系统课程设计报告进程调度算法

操作系统课程设计报告进程调度算法Minix 操作系统实践计算机科学与技术题 目 :姓 名 : 学 号 : 专业 : 指导教师 :实验一1.实验目的通过优先权法和轮转算法的模拟加深对进程概念和进程调度过程的理解,掌握进程状态之间的切换,同时掌握进程调度算法的实现方法和技巧。

2.实验内容1.用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 链接成就绪队列。

5.为了清楚地观察诸进程的调度过程,程序应将每个时间片内的进程的情况显示出来,3.实验步骤进程调度的思想(1)当系统空闲(就绪队列为空)时,系统运行闲逛进程,否则运行其他进程,发生变迁1(就绪→运行)。

(2)在运行进程(包括闲逛进程)的过程中,可能发生变迁2(运行→阻塞),即将运行进程插入到阻塞队列(闲逛进程不能被阻塞),可能有其他新的进程创建PCB,还可能唤醒阻塞队列中的某些进程PCB,发生变迁3(阻塞→就绪),即从阻塞队列中移出并插入就绪队列中。

(3)时间片运行结束后,若进程累计占用CPU 时间大于等于进程需要运行的时间,则进程执行结束,释放其PCB。

进程调度算法的课程设计

进程调度算法的课程设计

进程调度算法的课程设计一、课程目标知识目标:1. 学生能理解进程调度算法的基本概念,掌握其分类和各自特点。

2. 学生能描述并分析不同进程调度算法的优缺点及其适用场景。

3. 学生能运用进程调度算法解决实际问题,如进程优先级分配、CPU利用率优化等。

技能目标:1. 学生通过案例学习,培养分析问题、解决问题的能力,能设计简单的进程调度算法。

2. 学生能运用所学知识,对实际操作系统中的进程调度进行模拟和优化。

3. 学生能运用图表、流程图等工具,清晰、有条理地展示进程调度算法的过程。

情感态度价值观目标:1. 学生培养对计算机操作系统及进程调度算法的兴趣,激发探索计算机科学领域的热情。

2. 学生通过学习进程调度算法,认识到优化算法对提高计算机系统性能的重要性,增强社会责任感和创新意识。

3. 学生通过小组合作学习,培养团队协作精神,提高沟通、交流能力。

课程性质:本课程为计算机科学领域的基础课程,主要研究操作系统中进程调度算法的原理及其应用。

学生特点:学生已具备一定的计算机操作基础,对操作系统有初步了解,但进程调度算法较为抽象,需要结合实际案例进行讲解。

教学要求:结合实际案例,采用启发式教学,引导学生主动思考、探索和解决问题。

注重理论与实践相结合,培养学生的实际操作能力和创新意识。

通过小组合作、讨论等形式,提高学生的沟通能力和团队协作精神。

在教学过程中,关注学生的个体差异,因材施教,确保每个学生都能达到课程目标。

二、教学内容1. 进程调度算法概述:介绍进程调度算法的基本概念、目的和重要性。

- 理解进程与线程的区别,掌握进程调度的基本任务。

- 熟悉进程调度算法的分类,如先来先服务、短作业优先、优先级调度等。

2. 先来先服务调度算法(FCFS):分析算法原理、特点及优缺点。

- 学习FCFS算法的作业排序规则,分析其对作业执行时间的影响。

3. 短作业优先调度算法(SJF):介绍SJF算法的原理,比较其与FCFS算法的差异。

进程模拟调度算法课程设计

进程模拟调度算法课程设计

一.课程概述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)运行:进程已获得处理机,当前处于运行状态。

模拟进程调度算法课程设计

模拟进程调度算法课程设计

模拟进程调度算法课程设计.课程概述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、进程概念:进程是被独⽴分配资源的最⼩单位。

进程是动态概念,必须程序运⾏才有进程的产⽣。

进程调度模拟程序设计1

进程调度模拟程序设计1

进程调度模拟程序设计[ 标签:进程,调度,模拟 ]操作系统课程设计题目:进程调度模拟程序设计要求:编写一个进程调度程序,允许多个进程共享进程调度程序。

进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。

每个进程有一个进程控制块( PCB)表示。

进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。

进程的到达时间为输入进程的时间。

进程的运行时间以时间片为单位进行计算。

每个进程的状态可以是就绪 W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。

就绪进程获得 CPU后都只能运行一个时间片。

用已占用CPU时间加1来表示。

如果运行一个时间片后,进程的已占用 CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。

每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB,以便进行检查。

重复以上过程,直到所要进程都完成为止调度算法的流程图如下 :课程设计要求:1、分析设计要求,给出解决方案(要说明设计实现所用的原理,采用的数据结构)2、画出程序的基本结构框图和流程图3、所提交源程序应是能够运行通过的完整程序,程序中如有设置用户名和密码,应在课程设计说明书中明确说明并能运行。

4、对程序的每一部分要有详细的设计分析说明,程序执行的每个步骤要有具体的提示内容或输出。

5、源代码格式规范,注释不少于五分之一6、设计合适的测试用例,对得到的运行结果要有分析,7、设计中遇到的问题,设计的心得体会8、每个人提交完整程序代码、课程设计报告及相关文档等各一份9、提交的文档应以论文的格式书写,如封面、目录、摘要、关键词、详细的具体内容各章节、总结、参考文献与资料。

操作系统课程设计-进程调度算法模拟

操作系统课程设计-进程调度算法模拟

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

进程调度模拟程序 操作系统课程设计

进程调度模拟程序 操作系统课程设计

算法---进程调度模拟程序问题:进程调度模拟程序设计要求:编写一个进程调度程序,允许多个进程共行的进程调度程序。

进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。

每个进程有一个进程控制块(PCB)表示。

进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。

进程的到达时间为输入进程的时间。

进程的运行时间以时间片为单位进行计算。

每个进程的状态可以是就绪W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。

就绪进程获得CPU后都只能运行一个时间片。

用已占用CPU时间加1来表示。

如果运行一个时间片后,进程的已占用CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。

每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB,以便进行检查。

重复以上过程,直到所要进程都完成为止调度算法的流程图如下:算法实现过程:设计实现流程图设计思想说明:用定义结构体来表示进程控制块函数说明:AddProcess(): 来增加进程sort():按优先级和到达时间排序print():打印attemper():调度代码:#include "stdio.h"#include<windows.h>#define Time int#define Max 100typedef struct process{char name[10];//进程名int priority;Time ReachTime;//到达时间Time NeedTime;//需要时间Time UsedTime;//已用时间char state;//状态}PCB;//进程控制块int n;//标示进程的总数PCB pcb[Max];int pTime;//时间片大小void AddProcess(){char ch;do {system("cls");printf(" n 请输入进程名");scanf("%s",pcb[n].name);printf(" 请输入进程的优先级(0-10)");scanf("%d",&pcb[n].priority);printf(" 请输入进程需要的时间");scanf("%d",&pcb[n].NeedTime);pcb[n].ReachTime=n;pcb[n].UsedTime=0;pcb[n].state='W';n++;do{system("cls");printf("还要继续增加进程吗,是(Y),否(N)");ch=getche();} while(ch!='Y'&&ch!='N'&&ch!='y'&&ch!='n');}while (ch=='Y'||ch=='y');}// 排序函数,将最先运行的进程放在最先即pcb[0]{//用冒泡排序int i,j;PCB temp;//先按到达时间排序for (i=0;i<n-1;i++){for (j=n-2;j>=i;j--){if (pcb[j+1].ReachTime<pcb[j].ReachTime){temp=pcb[j];pcb[j]=pcb[j+1];pcb[j+1]=temp;}}}//再按优先级进行排序for (i=0;i<n-1;i++){for (j=n-2;j>=i;j--){if (pcb[j+1].priority>pcb[j].priority){temp=pcb[j];pcb[j]=pcb[j+1];pcb[j+1]=temp;}}}if (pcb[0].state!='F'){pcb[0].state='R';//将优先级最高的状态置为运行}}//打印void print(){int i;//system("cls");sort();printf(" n t进程名t优先级t到达时间t需要时间t已用时间t状态n");for (i=0;i<n;i++)printf("%10s%10d%10d%15d%15d%15cn",pcb[i].name,pcb[i].priority,pcb[i].ReachTime,pcb[i].NeedTime,pcb[i].UsedTime,pcb[i].state);}}//调度void attemper(){system("cls");printf("调度前:n");print();if ((pcb[0].NeedTime-pcb[0].UsedTime)>pTime){pcb[0].UsedTime+=pTime;//已用时间等于时间片pcb[0].priority--;//优先级减一pcb[0].state='W';}else{pcb[0].UsedTime=pcb[0].NeedTime;//已用时间等于需要时间pcb[0].priority=-1000;//优先级置为零pcb[0].state='F';//完成进程,将状态置为完成}printf("调度后: n");print();}char face(){char choose;printf(" n------------------------------------------- n");printf(" t增加进程,请按1 n");printf(" t打印进程,请按2 n");printf(" t进程调度,请按3 n");printf(" t结束进程请,按0 n");printf(" n------------------------------------------- n");printf(" t请选择:");do{choose=getche();} while(choose!='1'&&choose!='2'&&choose!='3'&&choose!='0');return choose;}void main(){char choose;n=0;//初始化进程数为0 printf("设置时间片的大小");scanf("%d",&pTime);system("cls");choose=face();do{if (choose=='1'){AddProcess();print();}if (choose=='2'){system("cls");print();}if (choose=='3'){attemper();}if (choose=='0'){return;}choose=face();} while(1);}。

进程调度模拟设计.时间片轮转、优先级法

进程调度模拟设计.时间片轮转、优先级法

学号:课程设计进程调度模拟设计——题目时间片轮转、优先级法学院计算机科学与技术学院专业班级姓名指导教师吴利君2013 年 1 月16 日课程设计任务书学生姓名:指导教师:吴利君工作单位:计算机科学与技术学院题目: 进程调度模拟设计——时间片轮转、优先级法初始条件:1.预备内容:阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解。

2.实践准备:掌握一种计算机高级语言的使用。

要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)1.模拟进程调度,能够处理以下的情形:⑴能够选择不同的调度算法(要求中给出的调度算法);⑵能够输入进程的基本信息,如进程名、优先级、到达时间和运行时间等;⑶根据选择的调度算法显示进程调度队列;⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。

2.设计报告内容应说明:⑴需求分析;⑵功能设计(数据结构及模块说明);⑶开发平台及源程序的主要部分;⑷测试用例,运行结果与运行情况分析;⑸自我评价与总结:i)你认为你完成的设计哪些地方做得比较好或比较出色;ii)什么地方做得不太好,以后如何改正;iii)从本设计得到的收获(在编写,调试,执行过程中的经验和教训);iv)完成本题是否有其他方法(如果有,简要说明该方法);时间安排:设计安排一周:周1、周2:完成程序分析及设计。

周2、周3:完成程序调试及测试。

周4、周5:验收、撰写课程设计报告。

(注意事项:严禁抄袭,一旦发现,一律按0分记)指导教师签名:年月日系主任(或责任教师)签名:年月日进程调度模拟设计——时间片轮转、优先级法一、需求分析无论是批处理系统、分时系统还是实时系统,用户进程数目一般都多余处理机数,这将直接导致用户进程相互争夺处理机。

另外,系统进程也同样需要使用处理机。

进程调度虽然是系统内部的低级调度,但进程调度算法的优劣直接影响作业调度的性能,因此一个好的调度策略对处理机的处理速度是至关重要的。

进程调度课程设计

进程调度课程设计

进程调度课程设计一、教学目标本节课的教学目标是让学生掌握进程调度的基本概念、算法和原则,能够运用所学知识分析和解决实际问题。

具体目标如下:1.知识目标:(1)了解进程调度的定义、目的和重要性;(2)掌握进程调度算法,如先来先服务、短作业优先、最高优先级等;(3)理解进程调度原则,如公平性、效率等。

2.技能目标:(1)能够运用进程调度算法分析系统性能;(2)能够根据实际需求设计合适的进程调度策略;(3)能够使用相关工具进行进程调度实验。

3.情感态度价值观目标:(1)培养学生对计算机系统的兴趣和好奇心;(2)培养学生具备解决实际问题的责任感和使命感;(3)培养学生团队协作和自主学习的意识。

二、教学内容本节课的教学内容主要包括以下几个部分:1.进程调度的概念:介绍进程调度的定义、目的和重要性,使学生了解进程调度在操作系统中的地位和作用。

2.进程调度算法:讲解先来先服务、短作业优先、最高优先级等进程调度算法,并通过实例分析各算法的优缺点。

3.进程调度原则:介绍进程调度原则,如公平性、效率等,使学生能够根据实际需求设计合适的进程调度策略。

4.进程调度实验:演示进程调度实验,使学生能够运用所学知识分析和解决实际问题。

三、教学方法为了提高教学效果,本节课将采用以下教学方法:1.讲授法:通过讲解进程调度的基本概念、算法和原则,使学生掌握相关知识。

2.讨论法:学生分组讨论,分享对进程调度算法的理解和观点,培养学生的团队协作能力。

3.案例分析法:分析实际案例,让学生了解进程调度在操作系统中的应用和作用。

4.实验法:安排进程调度实验,让学生动手实践,提高解决实际问题的能力。

四、教学资源为了支持教学内容和教学方法的实施,我们将准备以下教学资源:1.教材:选用权威、实用的教材,如《操作系统原理与实践》等;2.参考书:提供相关领域的参考书籍,如《计算机操作系统》等;3.多媒体资料:制作精美的PPT,生动展示进程调度的相关概念和实例;4.实验设备:配置适当的实验设备,如计算机、网络设备等,为学生提供实践机会。

操作系统课程设计进程调度模拟设计

操作系统课程设计进程调度模拟设计

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

进程调度算法 操作系统课程设计

进程调度算法  操作系统课程设计

计算机科学与应用系操作系统原理课程设计报告题目:进程调度算法班级: 0510074姓名: lee hye 专业:计算机科学与技术指导老师: hhh进程调度算法一、实验目的通过优先权法与轮转调度算法的模拟加深对进程概念和进程调度过程的理解,掌握进程状态之间的切换,同时掌握进程调度算法的实现方法和技巧。

二、实验内容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、进程管理程序调式好后,运行进程管理程序(1)输入1选择优先权调度算法模拟。

(2)输入开始进程个数n,创建n个PCB并加入就绪队列ready_queue中。

(3)就绪队列ready_queue不为空,调度就绪队列中第一个进程运行,否则,从闲逛队列idleprocess中调度闲逛进程运行。

(4)在运行过程中,当遇到阻塞,则该进程插入到阻塞队列block_queue 中,且将该进程从ready_queue中删除。

操作系统课程设计——进程调度模拟算法(5种)

操作系统课程设计——进程调度模拟算法(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先到先服务算法描述:把所有进程按到达先后排序,每次取最先到的进程执行后淘汰,再取下一个,直到所有进程调度完毕。

进程调度算法模拟程序设计

进程调度算法模拟程序设计

进程调度算法模拟程序设计一、背景介绍进程调度算法是操作系统中的一个重要概念,它决定了操作系统如何分配CPU时间片给不同的进程。

不同的调度算法有不同的优缺点,需要根据具体情况进行选择。

为了更好地理解和掌握进程调度算法,我们可以设计一个模拟程序来模拟不同的调度算法。

二、程序设计思路1. 定义进程结构体首先需要定义一个进程结构体,包含进程ID、到达时间、服务时间、开始时间、完成时间等信息。

这些信息是模拟程序中需要用到的基本信息。

2. 选择调度算法接下来需要选择要模拟的调度算法,常见的有先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)等。

不同的算法对应着不同的实现方法和数据结构。

3. 实现调度算法对于每种调度算法,都需要实现相应的函数来进行模拟。

比如对于FCFS算法,可以按照到达时间从小到大排序,然后依次执行每个进程;对于SJF算法,则需要按照服务时间从小到大排序,在每个时刻选择服务时间最短的进程执行;对于RR算法,则需要使用队列来保存就绪队列中的所有进程,并按照时间片轮转的方式依次执行。

4. 输出结果最后需要输出每个进程的开始时间、完成时间、周转时间、带权周转时间等信息,以便进行比较和分析。

三、程序设计实现1. 定义进程结构体```c++struct Process {int pid; // 进程IDint arriveTime; // 到达时间int serviceTime; // 服务时间int startTime; // 开始时间int finishTime; // 完成时间};```2. 选择调度算法这里我们选择实现FCFS算法。

FCFS算法的实现比较简单,只需要按照到达时间从小到大排序,然后依次执行每个进程即可。

3. 实现调度算法```c++void fcfs(vector<Process>& processes) {sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {return a.arriveTime < b.arriveTime;});int currentTime = 0;for (int i = 0; i < processes.size(); i++) {if (currentTime < processes[i].arriveTime) {currentTime = processes[i].arriveTime;}processes[i].startTime = currentTime;processes[i].finishTime = currentTime +processes[i].serviceTime;currentTime = processes[i].finishTime;}}```4. 输出结果```c++void printResult(const vector<Process>& processes) {double totalTurnaroundTime = 0, totalWeightedTurnaroundTime = 0;cout << "进程ID\t到达时间\t服务时间\t开始时间\t完成时间\t 周转时间\t带权周转时间" << endl;for (const auto& p : processes) {int turnaroundTime = p.finishTime - p.arriveTime;double weightedTurnaroundTime =(double)turnaroundTime / p.serviceTime;totalTurnaroundTime += turnaroundTime;totalWeightedTurnaroundTime += weightedTurnaroundTime;printf("%d\t%d\t%d\t%d\t%d\t%d\t%.2f\n", p.pid,p.arriveTime, p.serviceTime, p.startTime,p.finishTime, turnaroundTime, weightedTurnaroundTime);}int n = processes.size();printf("平均周转时间:%.2f\n", (double)totalTurnaroundTime / n);printf("平均带权周转时间:%.2f\n", totalWeightedTurnaroundTime / n);}```四、总结通过以上程序设计实现,我们可以更好地理解和掌握进程调度算法。

实验五 进程调度算法模拟

实验五 进程调度算法模拟

实验五进程调度算法模拟一、实验内容选择一个调度算法,模拟实现处理器调度。

二、实验目的在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。

当就绪状态进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。

本实验模拟在单处理器情况下处理器调度,帮助自己加深了解处理器调度的工作。

三、实验题目本实验有两个题,可选择其中的一题做实验。

第一题:设计一个按优先数调度算法实现处理器调度的程序。

[提示]:(1) 假定系统有五个进程,每一个进程用一个进程控制块PCB来代表,进程控制块的格式为:其中:➢进程名——作为进程的标识,假设五个进程的进程名分别为P1,P2,P3,P4,P5。

➢指针——按优先数的大小把五个进程连成队列,用指针指出下一个进程的进程控制块的首地址,最后一个进程中的指针为“0”。

➢要求运行时间——假设进程需要运行的单位时间数。

➢优先数——赋予进程的优先数,调度时总是选取优先数大的进程先执行。

➢状态——可假设有两种状态,“就绪8080”状态和“结束”状态。

五个进程的初始状态都为“就绪”,用“R”表示,当一个进程运行结束后,它的状态为“结束”,用“E”表示。

(2) 在每次运行你所设计的处理器调度程序之前,为每个进程任意确定它的“优先数”和“要求运行时间”。

本实验由于为了检查的方便,优先数和运行时间采用下表中的数值。

(3) 为了调度方便,把五个进程按给定的优先数从大到小连成队列。

用一单元指出队首进程,用指针指出队列的连接情况。

例:队首标志K1K2K3K4K5PCB1 PCB2 PCB3 PCB4 PCB5(4) 处理器调度总是选队首进程运行。

采用动态改变优先数的办法,进程每运行一次优先数就减“1”。

由于本实验是模拟处理器调度,所以,对被选中的进程并不实际的启动运行,而是执行:优先数-1要求运行时间-1来模拟进程的一次运行。

提醒注意的是:在实际的系统中,当一个进程被选中运行时,必须恢复进程的现场,让它占有处理器运行,直到出现等待事件或运行结束。

《高级语言程序设计》课程设计--进程调度模拟

《高级语言程序设计》课程设计--进程调度模拟

《高级语言程序设计》课程设计报告题目:进程调度模拟目录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程序功能介绍在多道程序环境下,进程数目往往多于处理机数目,致使他们争用处理机。

这就要求系统能按某种算法,动态地把处理机分配给就绪队列中的一个进程,使之运行。

分配处理机的任务是由进程调度程序完成的。

一个进程被建立后,系统为了便于对进程进行管理,将系统中的所有进程按其状态,将其组织成不同点进程队列。

于是系统中有运行进程队列、就绪队列和各种事件的进程等待队列。

模拟进程调度功能的设计与实现操作系统课程设计(JAVA版本)

模拟进程调度功能的设计与实现操作系统课程设计(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. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 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.算法思想进程的执行顺序由高优先级到低优先级,系统或用户按某种原则为进程指定一个优先级来表示该进程所享有的确调度优先权。

相关文档
最新文档