时间片轮转算法课程设计
时间片轮转算法课程设计
一、实验目的本课程设计以Windows操作系统为实验平台,进行源代码分析和修改。
通过该课程设计,使学生掌握Windows操作系统各部分结构、实现机理和各种典型算法;系统地了解操作系统的设计和实现思路,运用内核开发环境实现对内核的修改,培养学生的系统设计能力,并了解操作系统的发展动向和趋势。
二、实验内容1.分析设计内容,给出解决方案(要说明设计实现的原理,采用的数据结构)。
2.画出程序的基本结构框图和流程图。
3.对程序的每一部分要有详细的设计分析说明。
4.源代码格式要规范。
5.设计合适的测试用例,对得到的运行结果要有分析。
6.设计中遇到的问题,设计的心得体会。
7.按期提交完整的程序代码、可执行程序和课程设计报告。
三、实验步骤1、任务分析:时间片轮转的主要思想就是按顺序为每一个进程一次只分配一个时间片的时间。
算法要完成的功能就是将各个进程按照时间片轮转运行的动态过程显示出来。
时间片轮转算法的主要实现过程是首先为每一个进程创建一个进程控制块,定义数据结构,说明进程控制块所包含的内容,有进程名、进程所需运行时间、已运行时间和进程的状态以及指针的信息。
实现的过程即运用指针指向某一个进程,判断当前的进程是否是就绪状态“r”,如果是,则为该进程分配一个时间片,同时,已运行时间加一且要求运行的时间减一,如此循环执行,当某一个进程的所需要运行的时间减少至0时,则将该进程的状态设置为“e”。
然后,将指针指向下一个未运行完成的进程,重复判断,直至所有的进程都运行结束。
2、概要设计:(1)所用数据结构及符号说明typedef struct PCB{char name[10]; //进程名struct PCB *next; //循环链指针int need_time; //要求运行时间int worked_time; //已运行时间,初始为0char condition; //进程状态,只有“就绪”和“结束”两种状态int flag; //进程结束标志,用于输出}PCB;PCB *front,*rear; //循环链队列的头指针和尾指针int N; //N为进程数(2)主程序的流程图:PCB1 PCB2 PCB3 PCB4 PCB5 (3)程序详细设计步骤:a.首先建立PCB的数据结构,为了便于正确输出,加上了进程结束标志flag。
操作系统课程设计时间片轮转算法java实现
操作系统课程设计时间片轮转算法j a v a实现 Document serial number【UU89WT-UU98YT-UU8CB-UUUT-UUT108】学校代码:10128课程设计题目:处理机管理模拟系统的设计与实现学生姓名:学院:信息工程学院系别:软件工程系专业:软件工程班级:指导教师:副教授讲师2013年1月8日内蒙古工业大学课程设计任务书(四)学院(系):信息学院软件工程系课程名称:操作系统课程设计指导教师(签名):专业班级:学生姓名:学号:摘要操作系统是计算机系统的关键组成部分,负责管理与配置内存、决定系统资源供需的优先次序、控制输入与输出设备、操作网络与管理文件系统等基本任务。
对于不同的系统和系统目标,通常采用不同的调度算法,如在批处理系统中,为照顾为数众多的短作业,采用短作业优先调度算法;在分时系统中,为保证系统具有合理的响应时间,采用时间片轮转法进行调度。
采用算法时,则要考虑多方面因素,以便达到最佳效果。
本次课程设计采用时间片轮转调度算法来实现模拟进程调度任务的执行过程。
用Java模拟进程调度过程,可以方便地将运行结果直观地表示出来。
Java语言独有的多线程操作,可以实现许多其他语言不能实现的功能,极大地方便了程序开发人员对程序的开发。
此外,利用JavaGUI编程,可以使系统提供的界面更加友好。
实验中,应用文件I/O操作、线程、AWT、Swing、内部类、接口、异常处理等技术,开发此系统。
关键字:时间片轮转; Java编程; GUI图形用户界面;文件操作;AbstractThe operating system is a key component of the computer system, responsible for the management and configuration memory, decided to system resources supply and demand priority, control input and output equipment, operation and management of network file system, and other basic different systems and system target, computers usually use different scheduling algorithm, such as in a Batch Processing System, in order to take care of a lot of short operation, using Short Job First algorithm;In systems with time sharing, to ensure the system has reasonable response time, need time slice Round Robin algorithm for scheduling. The algorithm, we should consider various factors, in order to achieve the best Course Design uses time slice Round Robin algorithm to simulate the process scheduling task execution process.With Java simulation process scheduling process, which can be conveniently will run results intuitively said addition, the use of JavaGUI programming, can make the system to provide theinterface more , application file I/O operation, threads, AWT, Swing, internal class, interface, abnormal processing technology, the development of this system.Keywords: time slice Round Robin; Java Programming; ;File Operation;目录第一章问题分析设计目的在多道程序或多任务系统中,系统同时处于就绪态的进程有若干个。
采用时间片轮转算法调度程序
采用时间片轮转算法调度程序学号:姓名:专业:指导教师:日期:目录一、需求分析 (3)1、设计要求: (3)2、解决方案: (3)二、课程设计简介 (4)1、课程设计题目 (4)2、课程设计目的 (4)3、课程设计内容 (4)4、时间安排 (4)三、概要设计 (4)1、基本原理 (4)2、算法思想设计 (5)3、数据结构及模块说明: (5)四、主要函数及其说明 (6)五、调试分析 (7)1、调试过程及步骤 (7)2、结果分析(以三个进程数为例) (8)六、总结及参考文献 (9)1、总结: (9)2、参考文献 (9)附录:程序源代码 (9)一、需求分析1、设计要求:在多道程序或多任务系统中,系统同时处于就绪状态的进程有若干个。
为了使系统中各进程能有条不紊地进行,必须选择某种调度策略,以选择一进程占用处理机。
要求用时间片轮转算法模拟单处理机调度,以巩固和加深处理机调度的概念。
2、解决方案:(1)、假设系统有5个进程,每个进程用一个进程控制块PCB来表示。
PCB包括:进程名、链接指针、到达时间、估计运行时间和进程状态。
其中,进程名即进程标识。
链接指针指出下一个到达进程的进程控制块地址,按照进程到达的顺序排队,统设置一个队头和队尾指针分别指向第一个和最后一个进程,新生成的进程放队尾。
估计运行时间:可由设计者任意指定一个时间值。
到达时间:进程创建时的系统时间或由用户指定,调度时,总是选择到达时间最早的进程。
进程状态:为简单起见,假定进程有三种状态,就绪、等待和完成,并假定进程一创建就处于就绪状态,用R表示,当一个进程运行结束时,就将其置成完成状态,用F表示。
当一个进程未运行完成并且时间片不足时,就将其置成等待状态,用W表示。
(2)、为每个进程任意确定一个要求运行时间和到达时间。
(3)、按照进程到达的先后顺序排成一个循环队列。
再设一队首指针指向第一个到达进程的首址。
(4)、执行处理机调度时,开始选择队首的第一个进程运行。
时间片轮转、强占式短进程优先算法
学号:课程设计题目进程调度模拟设计——时间片轮转、强占式短进程优先算法学院计算机科学与技术学院专业班级姓名指导教师吴利军2013 年 1 月16 日课程设计任务书学生姓名:指导教师:吴利军工作单位:计算机科学与技术学院题目: 进程调度模拟设计——时间片轮转、强占式短进程优先算法初始条件:1.预备内容:阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解。
2.实践准备:掌握一种计算机高级语言的使用。
要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)1.模拟进程调度,能够处理以下的情形:⑴能够选择不同的调度算法(要求中给出的调度算法);⑵能够输入进程的基本信息,如进程名、到达时间和运行时间等;⑶根据选择的调度算法显示进程调度队列;⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。
2.设计报告内容应说明:⑴需求分析;⑵功能设计(数据结构及模块说明);⑶开发平台及源程序的主要部分;⑷测试用例,运行结果与运行情况分析;⑸自我评价与总结:i)你认为你完成的设计哪些地方做得比较好或比较出色;ii)什么地方做得不太好,以后如何改正;iii)从本设计得到的收获(在编写,调试,执行过程中的经验和教训);iv)完成本题是否有其他方法(如果有,简要说明该方法);时间安排:设计安排一周:周1、周2:完成程序分析及设计。
周2、周3:完成程序调试及测试。
周4、周5:验收、撰写课程设计报告。
(注意事项:严禁抄袭,一旦发现,一律按0分记)指导教师签名:年月日系主任(或责任教师)签名:年月日进程调度模拟设计时间片轮转、强占式短进程优先算法一、需求分析本次课程设计需要通过设计一个模拟进程调度的系统,来实现进程调度过程的模拟,对进程调度的功能以及进程调度的算法有更加深层次的理解。
时间片轮转法的基本思路是每个进程被分配一个时间段,称作它的时间片,即该进程允许运行的时间。
如果在时间片结束时进程还在运行,则CPU将被剥夺并分配给另一个进程。
计算机操作系统时间片循环轮转算法
Proc p=H->n ext;
while (p->All_Time > p->Ru ned_Time) { //即未结束的进程
roun d++;
cout<<endl<<"Round "<<round<<"--正在运行"<<p->name<<"进程"<<endl;
PCB3
PCB4
PCB5
(4)处理器调度总是选择标志单元指示的进程运行。由于本实验是模拟处理器调度的功能,
所以,对被选中的进程并不实际的启动运行,而是执行:
已运行时间+1
来模拟进程的一次运行,表示进程已经运行过一个单位的时间。
请注意:在实际的系统中,当一个进程被选中运行时,必须置上该进程可以运行的时间片值,
do {
if (p->state != 'E') //如果该进程的状态不是End的话
{
cout<<"进程名:"<<p->name<<"\t总运行时间:"<<p->All_Time
<<"\t已运行时间:"<<p->Runed_Time
<<"\t状态:"<<p->state<<endl;
p=p->n ext;
(2)每次运行所设计的进程调度程序前,为每个进程任意确定它的“要求运行时间”。
计算机操作系统时间片循环轮转算法
计算机操作系统时间片循环轮转算法实验报告书课程名:«计算机操作系统»题目:时间片循环轮转调度班级:软件081班学号:110831116姓名:陈点点(4) 处置器调度总是选择标志单元指示的进程运转。
由于本实验是模拟处置器调度的功用,所以,对被选中的进程并不实践的启动运转,而是执行:已运转时间+1来模拟进程的一次运转,表示进程曾经运转过一个单位的时间。
请留意:在实践的系统中,当一个进程被选中运转时,必需置上该进程可以运转的时间片值,以及恢复进程的现场,让它占有处置器运转,直到出现等候事情或运转满一个时间片。
在这时省去了这些任务,仅用〝已运转时间+1〞来表示进程曾经运转满一个时间片。
(5) 进程运转一次后,应把该进程的进程控制块中的指针值送到标志单元,以指示下一个轮到运转的进程。
同时,应判别该进程的要求运转时间与已运转时间,假定该进程的要求运转时间 已运转时间,那么表示它尚未执行完毕,应待到下一轮时再运转。
假定该进程的要求运转时间=已运转时间,那么表示它曾经执行完毕,应指点它的形状修正成〝完毕〞〔E〕且参与队列。
此时,应把该进程的进程控制块中的指针值送到前面一个进程的指针位置。
(6) 假定〝就绪〞形状的进程队列不为空,那么重复下面的〔4〕和〔5〕的步骤,直到一切的进程都成为〝完毕〞形状。
(7) 在所设计的顺序中应有显示或打印语句,能显示或打印每次选中进程的进程名以及运转一次后进程队列的变化。
(8) 为五个进程恣意确定一组〝要求运转时间〞,启动所设计的处置器调度顺序,显示或打印逐次被选中的进程名以及进程控制块的静态变化进程。
五、流程图与源顺序int ProcNum; // 总进程个数// 初始化就绪队列void InitPCB(Proc &H) {cout<<"请输入总进程个数: ";cin>>ProcNum; // 进程总个数int Num=ProcNum;H=(Proc)malloc(sizeof(PNode)); // 树立头节点H->next=NULL;Proc p=H; //定义一个指针cout<<"总进程个数为 "<<ProcNum<<" 个,请依次输入相应信息\n\n";while (Num--) {p=p->next=(Proc)malloc(sizeof(PNode));cout<<"进程名总运转时间已运转时间 :";cin>>p->name>>p->All_Time>>p->Runed_Time;p->state='R';p->next=NULL;}p->next=H->next;}//输入运转中的进程信息void DispInfo(Proc H) {Proc p=H->next;do {if (p->state != 'E') //假设该进程的形状不是End的话{cout<<"进程名:"<<p->name<<"\t总运转时间:"<<p->All_Time <<"\t已运转时间:"<<p->Runed_Time<<"\t形状:"<<p->state<<endl;p=p->next;}else p=p->next;} while (p != H->next); // 整个进程链条一直完整,只是形状位有差异}// 时间片轮转法void SJP_Simulator(Proc &H) {cout<<endl<<"-------------------START--------------------\n";int flag=ProcNum; // 记载剩余进程数int round=0; // 记载轮转数Proc p=H->next;while (p->All_Time > p->Runed_Time) { // 即未完毕的进程round++;cout<<endl<<"Round "<<round<<"--正在运转 "<<p->name<<" 进程"<<endl; p->Runed_Time++; // 更矫正在运转的进程的已运转时间DispInfo(H); // 输入此时为就绪形状的进程的信息if (p->All_Time == p->Runed_Time) { // 并判别该进程能否完毕p->state='E';flag--;cout<<p->name<<" 进程已运转完毕,进程被删除!\n";}p=p->next;while (flag && p->All_Time == p->Runed_Time)p=p->next; // 跳过先前已完毕的进程}cout<<endl<<"--------------------END---------------------\n";}void main() {Proc H;InitPCB(H); // 数据初始化DispInfo(H); // 输入此刻的进程形状SJP_Simulator(H); // 时间片轮转法system("pause");}六、测试数据与实验结果七、结果剖析与实验体会时间片轮转算法中,系统将一切的就绪顺序按先来先效劳的原那么排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片。
时间片轮转课程设计讲解
武汉理工大学华夏学院课程设计报告书课程名称:操作系统原理题目:时间片轮转调度算法系名:信息工程系专业班级:姓名:学号:指导教师:司晓梅2015 年 6 月 26 日武汉理工大学华夏学院信息工程系课程设计任务书课程名称:操作系统原理课程设计指导教师:司晓梅班级名称:计算机1131-2 开课系、教研室:自动化与计算机一、课程设计目的与任务操作系统课程设计是《操作系统原理》课程的后续实践课程,旨在通过一周的实践训练,加深学生对理论课程中操作系统概念,原理和方法的理解,加强学生综合运用操作系统原理、Linux系统、C语言程序设计技术进行实际问题处理的能力,进一步提高学生进行分析问题和解决问题的能力,包含系统分析、系统设计、系统实现和系统测试的能力。
学生将在指导老师的指导下,完成从需求分析,系统设计,编码到测试的全过程。
二、课程设计的内容与基本要求1、课程设计题目时间片轮转进程调度模拟算法的实现2、课程设计内容用c/c++语言实现时间片轮转的进程调度模拟算法。
要求:1.至少要有5个以上进程2.进程被调度占有CPU后,打印出该进程正在运行的相关信息提示:时间片轮转调度算法中,进程调度程序总是选择就绪队列中的第一个进程,也就是说按照先来先服务原则调度,但一旦进程占用处理机则仅使用一个时间片。
在使用完一个时间片后,进程还没有完成其运行,它必须释放出处理机给下一个就绪的进程,而被抢占的进程返回到就绪队列的末尾重新排队等待再次运行。
1)进程运行时,只打印出相关提示信息,同时将它已经运行的时间片加1就可以了。
2)为进程设计出PCB结构。
PCB结构所包含的内容,有进程名、进程所需运行时间、已运行时间和进程的状态以及指针的信息等。
3、设计报告撰写格式要求:1设计题目与要求 2 设计思想3系统结构 4 数据结构的说明和模块的算法流程图5 使用说明书(即用户手册):内容包含如何登录、退出、读、写等操作说明6 运行结果和结果分析(其中包括实验的检查结果、程序的运行情况)7 自我评价与总结 8 附录:程序清单,注意加注释(包括关键字、方法、变量等),在每个模块前加注释;三、课程设计步骤及时间进度和场地安排本课程设计将安排在第17周, 现代教育技术中心。
时间片轮转调度算法设计与实现
郑州轻工业学院实验报告课程名称:操作系统姓名:学号:专业班级:任课教师:黄伟2016 年11 月 2 日实验报告成绩评定表实验报告正文实验二时间片轮转调度算法设计与实现一、实验目的目的:了解并掌握时间片轮转调度算法的理论,熟悉并掌握时间片设置的大小对系统的影响。
任务:模拟实现时间片轮转调度算法。
二、实验内容1.任务描述1)时间片轮转调度算法问题简介时间片轮转的主要思想就是按顺序为每一个进程一次只分配一个时间片的时间。
算法要完成的功能就是将各个进程按照时间片轮转运行的动态过程显示出来。
时间片轮转算法的主要实现过程是首先为每一个进程创建一个进程控制块,定义数据结构,说明进程控制块所包含的内容,有进程名、进程所需运行时间、已运行时间和进程的状态以及指针的信息。
实现的过程即运用指针指向某一个进程,判断当前的进程是否是就绪状态“r”,如果是,则为该进程分配一个时间片,同时,已运行时间加一且要求运行的时间减一,如此循环执行,当某一个进程的所需要运行的时间减少至0时,则将该进程的状态设置为“e”。
然后,将指针指向下一个未运行完成的进程,重复判断,直至所有的进程都运行结束。
2)设计任务简介模拟实现时间片轮转调度算法,具体如下:设置进程体:进程名,进程的到达时间,服务时间,,进程状态(W——等待,R——运行,F——完成),进程间的链接指针进程初始化:由用户输入进程名、服务时间进行初始化,同时,初始化进程的状态为W。
显示函数:在进程调度前、调度中和调度后进行显示。
排序函数:对就绪状态的进程按照进入就绪队列的时间排序,新到达的进行应优先于刚刚执行过的进程进入就绪队列的队尾。
注意考虑到达时间调度函数:每次从就绪队列队首调度优一个进程执行,状态变化。
并在执行一个时间片后化,服务时间变化,状态变化。
当服务时间为0时,状态变为F。
删除函数:撤销状态为F的进行。
2.调度问题的表示方案首先每一个进程用一个进程控制块PCB来代表。
时间片轮转调度算法
时间⽚轮转调度算法实验⼆时间⽚轮转调度算法实验内容:模拟实现时间⽚轮转调度算法,具体如下:设置进程体:进程名,进程的到达时间,服务时间,,进程状态(W——等待,R——运⾏,F ——完成),进程间的链接指针进程初始化:由⽤户输⼊进程名、服务时间进⾏初始化,同时,初始化进程的状态为W。
显⽰函数:在进程调度前、调度中和调度后进⾏显⽰。
排序函数:对就绪状态的进程按照进⼊就绪队列的时间排序,新到达的进⾏应优先于刚刚执⾏过的进程进⼊就绪队列的队尾。
注意考虑到达时间调度函数:每次从就绪队列队⾸调度优⼀个进程执⾏,状态变化。
并在执⾏⼀个时间⽚后化,服务时间变化,状态变化。
当服务时间为0时,状态变为F。
删除函数:撤销状态为F的进⾏。
实验要求:1、测试数据可以随即输⼊或从⽂件中读⼊。
2、必须要考虑到进程的到达时间3、最终能够计算每⼀个进程的周转时间的带权周转时间。
实验代码:#include#include#includeusing namespace std;int n;class PCB{public:int pri;int runtime;int pieceOftime;string procname;string state;int needOftime;int Counter;PCB * next;};PCB * run = NULL;PCB * finish = NULL;PCB * tial = ready;void Dtime(int t);void Prinft(int a){if(a==1){cout<<"\n进程名\t到达时间\t服务时间\t时间⽚\t进程状态"<}}void Prinft(int b,PCB * p){if(b==1){cout<procname<<"\t"<needOftime<<"\t\t"<runtime<<"\t\t"<pieceOftime<<"\t"<state< }}void display(int c){PCB *p;if(run!=NULL)Prinft(c,run);p=ready;while(p!=NULL){Prinft(c,p);p=p->next;}p=finish;while(p!=NULL){Prinft(c,p);p=p->next;}void insert(PCB *p){PCB *S1,*S2;if(ready==NULL){p->next = NULL;ready = p;}else{S1 = ready;S2 = S1;while(S1!=NULL){if(S2->pri >= p->pri){S2->next = p;p->next = S1;}else{p->next = ready;ready = p;}}}}bool CTProcessOfPri(){PCB * Node;cout <<"输⼊创建进程的数⽬:"< cin >>n;for(int j = 0;j < n; j++)Node = new PCB;if(Node==NULL)return false;else{cout <<"输⼊进程的名称,进程需CPU时间:"< cin >>Node->procname>>Node->needOftime; Node->runtime = 0;Node->state ="就绪";Node->pri =Node->needOftime;cout <<"进程"<procname<<"创建完毕!"<}insert(Node);}return true;}void priority(int i){run = ready;ready = ready->next;run->state = "运⾏";Prinft(i);while(run!=NULL){run->runtime=run->runtime+1;run->needOftime=run->needOftime-1;run->pri=run->pri-1;if(run->needOftime==0){run->state = "完成";run->next = finish;finish = run;run=NULL;if(ready!=NULL)run = ready;run->state = "运⾏";ready = ready->next;}}else if((ready!=NULL)&&(run->pripri)) {run->state="就绪";insert(run);run = ready;run->state = "运⾏";ready = ready->next;}display(i);}}void queue(PCB *p){if(ready==NULL){p->next = NULL;ready = p;tial = p;}else{tial->next = p;tial = p;p->next = NULL;}}bool CTProcessOfRuntime(){PCB * Node;cout <<"输⼊创建进程的数⽬:"<cin >>n;cout <<"输⼊时间⽚:"<cin >>m;for(int j = 0;j < n; j++){Node = new PCB;if(Node==NULL)return false;else{cout <<"输⼊进程的名称,进程需CPU时间:"< cin >>Node->procname>>Node->needOftime; Node->runtime = 0;Node->state ="就绪";Node->Counter = 0;Node->pieceOftime = m;cout <<"进程"<procname<<"创建完毕!"<}queue(Node);}return true;}void Runtime(int c){run = ready;ready = ready->next;run->state = "运⾏";Prinft(c);while(run!=NULL){run->runtime=run->runtime+1;run->needOftime=run->needOftime-1;run->Counter = run->Counter + 1;{run->state = "完成";run->next = finish;finish = run;run = NULL;if(ready!=NULL){run = ready;ready = ready->next;}}else if(run->Counter == run->pieceOftime){run->Counter = 0;run->state = "就绪";queue(run);run=NULL;if(ready!=NULL){run = ready;run->state = "运⾏";ready = ready->next;}}display(c);}}int main(){int i;cout <<"----------时间⽚轮转调度算法---------"< cout <<"--------- 1 开始 2 退出---------\n\n选择:"< cin >>i;switch(i)case 1: CTProcessOfRuntime(); Runtime(i);break;case 2:break;}return 0;}void Dtime(int t){time_t current_time;time_t start_time;time(&start_time);do{time(& current_time);}while((current_time-start_time)实验结果:。
操作系统课程设计报告-基于时间片的轮转调度算法[61页].doc
操作系统课程设计报告选题名称:基于时间片的高优先级调度模拟实现系(院):经济管理学院专业:信息管理与信息系统班级:信管1091设计任务书课题名称基于时间片的高优先级调度模拟实现设计目的1.理解进程调度相关理论。
2.掌握时间片调度原理。
3.掌握高优先级调度原理。
实验环境1.硬件:PC机,奔腾IV以上CPU,512MB以上内存,80G以上硬盘。
2.软件:Windows2000/XP、Microsoft Visual C++ 6.0。
任务要求1.搜集基于时间片的高优先级调度模拟实现可能涉及到的知识和相关资料。
2.应用Microsoft Visual C++ 6.0集成开发环境,设计并实现一个基于时间片的高优先级调度模拟程序。
3.确保基于时间片的高优先级调度模拟程序能正确运行。
4.参加答辩,撰写课程设计报告。
工作进度计划序号起止日期工作内容1 2012.1.1 课题任务下达,查阅文献资料2 2012.1.2~2012.1.3 课题总体设计、素材搜集与处理3 2012.1.4~2012.1.7 课题详细设计、调试、完善设计4 2012.1.8 答辩,撰写报告指导教师(签章):年月日摘要操作系统(Operating System,简称OS)是计算机系统的重要组成部分,是一个重要的系统软件,它负责管理计算机系统的硬、软件资源和整个计算机的工作流程,协调系统部件之间,系统与用户之间、用户与用户之间的关系。
随着操作系统的新技术的不断出现功能不断增加。
操作系统作为一个标准的套装软件必须满足尽可能多用户的需要,于是系统不断膨胀,功能不断增加,并逐渐形成从开发工具到系统工具再到应用软件的一个平台环境。
更能满足用户的需求。
随着计算机技术的不断发展,人们对于计算机系统性能的要求也越来越高,对于操作系统所使用的算法也在不断地发展。
OS对调度分配实质是一种资源分配,因而调度算法要根据不同的系统资源分配策略所规定的来分配算法。
对于不同的系统目标,又必须采用不同的调度算法。
2-时间片轮转rr算法[整理版]
操作系统实验报告一、实验题目时间片轮转算法(RR算法)二、实验目的模拟实现时间片轮转调度算法。
理解时间轮转算法的处理机调度的基本思想。
三、实验要求1.初始化函数,输入各个进程的到达时间以及需要的运行的时间。
2.设置时间片大小,实现进程有等待到运行状态的转换。
3.进程运行时间结束后从进程列表中删除该进程。
四、实验内容在时间片调度算法的模拟实现中,时间片就是分配给进程运行的一段时间。
在轮转法中,系统将所有的可运行(即就绪)进程按先来先服务的原则,排成一个队列,每次调度时把CPU分配给队首进程,并令其执行一个时间片。
当某进程执行的时间片用完时,系统发出信号,通知调度程序,调度程序便据此信号来停止该进程的执行,并将刚运行的进程送到运行队列的末尾,等待下一次执行;然后,把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。
这样就可以保证运行队列中的所有进程,在一个给定的时间内,均能获得一时间片的处理机执行时间。
本实验设计一个有N个进程并发的进程调度程序,采用时间片轮转算法。
每一个进程用一个进程控制块PCB表示。
PCB包含信息有:进程名nme,进程号id,进程状态stte,进程所需运行时间need_time,进程运行时间run_time。
进程运行时间以时间片为单位进行计算。
(程序中以按任意键表示运行一次CPU时间片)每个进程的状态有就绪W,运行R,和完成(撤销进程)。
就绪的进程获得CPU后只能运行一个时间片,运行完运行时间run_time+1。
如果运行一个时间片后,进程的run_time等于need_time(即已经达到所需运行时间),则撤销该进程并提示,如果还未达到,则将其放到队尾,进入就绪状态等待下一次时间片分配。
每一次调度程序都打印一次运行情况,包括:运行的进程,就绪队列的进程,已经所有进程的PCB(不包括已经撤销的进程)。
五、实验结果:六、实验小结由于自己自编写代码方面与他人有一定的差距,因此在做实验的过程中我在网上搜了很多相关的资料,了解实现该算法的原理及各部分实现的代码,同时参考了几个别人写好的源代码,然后自己在理解的基础上不断的根据要求修改写程序,不过其中碰见的很多的问题。
时间片轮转课程设计样本
武汉理工大学华夏学院课程设计报告书课程名称:操作系统原理 _______题目:时间片轮转调度算法系名: ____________ 信息工程系_________ 专业班级: _____________________姓名:_____________________________ 学号:________________________指导教师: _________ 司晓梅____________年_6_月26 日武汉理工大学华夏学院信息工程系课程设计任务书课程名称:操作系统原理课程设计指导教师:司晓梅班级名称:计算机1131-2开课系、教研室:自动化与计算机一、课程设计目的与任务操作系统课程设计是《操作系统原理》课程的后续实践课程,旨在经过一周的实践训练,加深学生对理论课程中操作系统概念,原理和方法的理解,加强学生综合运用操作系统原理、Linux 系统、C语言程序设计技术进行实际问题处理的能力,进一步提高学生进行分析问题和解决问题的能力,包含系统分析、系统设计、系统实现和系统测试的能力。
学生将在指导老师的指导下,完成从需求分析,系统设计,编码到测试的全过程。
二、课程设计的内容与基本要求1、课程设计题目时间片轮转进程调度模拟算法的实现2、课程设计内容用C/C++语言实现时间片轮转的进程调度模拟算法。
要求1. 至少要有5个以上进程2. 进程被调度占有CPU后,打印出该进程正在运行的相关信息提示:时间片轮转调度算法中,进程调度程序总是选择就绪队列中的第一个进程,也就是说按照先来先服务原则调度,但一旦进程占用处理机则仅使用一个时间片。
在使用完一个时间片后,进程还没有完成其运行它必须释放出处理机给下一个就绪的进程而被抢占的进程返回到就绪队列的末尾重新排队等待再次运行。
1)进程运行时,只打印出相关提示信息,同时将它已经运行的时间片加1就能够了。
2)为进程设计出PCB吉构。
PCB吉构所包含的内容,有进程名、进程所需运行时间、已运行时间和进程的状态以及指针的信息等。
操作系统时间片轮转算法
进程时间片轮转调度算法一、实验题目:进程时间片轮转调度算法二、实验原理:在多道程序系统中,一个作业被提交后必须经过处理机调度后,方能获得处理机执行。
对调度的处理又都可采用不同的调度方式和调度算法。
调度算法是指:根据系统的资源分配策略所规定的资源分配算法。
三、实验目的:1、加深对进程概念的理解,明确进程和程序的区别。
2、深入系统如何组织进程、创建进程。
3、进一步认识如何实现处理器调度。
4、通过对进程调度算法的设计,深入理解进程调度的原理。
5、加深对时间片轮转调度算法的理解。
四、实验要求:用C语言编写程序完成单处理机的进程调度,要求采用时间片轮转调度算法。
实验具体要求包括:首先确定作业控制块的内容和组成方式;然后完成作业调度;最后编写主函数,并对所做工作进行测试。
五、运行结果时间片大小为1时(q=1):时间片大小为4时(q=4):六、代码#include"stdafx.h"#include<stdio.h>#include<stdlib.h>#include<string.h>#include<windows.h>#define OK 0#define OVERFLOW 1char pro[20] ; //进程int processNum; //进程数int timeSlice = 0; //时间片typedefchar QlemTypeChar;typedefint QlemTypeInt;typedefint Status;typedefstruct QNode{QlemTypeChar data;QlemTypeInt timeArrive = 0;QlemTypeInt timeService = 0;QlemTypeInt timeCount = 0;QlemTypeInt runCount = 0;QlemTypeInt timeFinal = 0; //完成时间QlemTypeInt timeRound = 0; //周转时间float timeRightRound = 0; //带权周转时间QlemTypeChar proState = 'W'; //进程的状态,W——就绪态,R——执行态,F——完成态struct QNode *next; //链表指针}QNode, *QueuePtr;typedefstruct{QueuePtr front; //队头指针QueuePtr rear; //队尾指针}LinkQueue;Status InitQueue(LinkQueue &Q){Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));if(!Q.front) exit(OVERFLOW);Q.front->next = NULL;return OK;}Status EnQueue(LinkQueue &Q, QlemTypeChar e){ QueuePtr p;p = (QueuePtr)malloc(sizeof(QNode));if (!p) exit(OVERFLOW);p->data = e;p->next = NULL;Q.rear->next = p;Q.rear = p;return OK;}Status DeQueue(LinkQueue &Q, QlemTypeChar &e){ QueuePtr p;if (Q.front == Q.rear) return ERROR;p = Q.front->next;e = p->data;Q.front->next = p->next;if (Q.rear == p) Q.rear = Q.front;free(p);return OK;}QNode qq[10];void ProGetFirst(){ //取出就绪队列队首进程InitQueue(QPro);printf("请输入要创建的进程名称:\n");for (int i = 0; i < processNum-1; i++){fflush(stdin);scanf_s("%c", &pro[i]);}fflush(stdin);for (int i = 0; i<processNum-1; i++){qq[i].data = pro[i];EnQueue(QPro, qq[i].data);}}void scanfData(){printf("请输入要创建的进程数目:");scanf_s("%d", &processNum);processNum++;fflush(stdin);printf("\n");ProGetFirst();printf("创建进程到达时间:\n");for (int i = 0; i < processNum-1; i++){scanf_s("%d", &time_Arr[i]);}for (int i =0; i<processNum-1; i++){qq[i].timeArrive = time_Arr[i];EnQueue(QPro, qq[i].timeArrive);}printf("创建进程服务时间:\n");int time_Ser[10];for (int i = 0; i < processNum-1; i++){scanf_s("%d", &time_Ser[i]);}for (int i = 0; i<processNum-1; i++){qq[i].timeService = time_Ser[i];EnQueue(QPro, qq[i].timeService);}printf("请输入时间片大小::");scanf_s("%d", &timeSlice);printf("\n");}void ProOutPut1(){ //获取进程信息printf("进程名\t 到达时间\t 服务时间\t 进程状态\t 执行次数\n"); for (int i = 0; i < processNum - 1; i++){printf("%c\t\t%d\t\t%d\t\t%c\t\t%d\n", qq[i].data, qq[i].timeArrive, qq[i].timeService, qq[i].proState, qq[i].runCount); }}void CalculatetimeFinal(){ //计算完成时间int timecou=0;int countTemp = 0;QlemTypeChar ee;for (int i = 0; i < processNum - 1; i++){countTemp += qq[i].timeService;}while (timecou < countTemp){for (int i = 0; i < processNum - 1; i++){if (qq[i].timeFinal == 0){if (qq[i].timeService - qq[i].timeCount >= timeSlice){timecou += timeSlice;}else{timecou += (qq[i].timeService - qq[i].timeCount);//DeQueue(QPro, ee);}if (timeSlice < qq[i].timeService) //时间片大小< 服务时间{int timetemp = timeSlice > qq[i].timeService ? qq[i].timeService : timeSlice; if ((qq[i].timeCount + timetemp) < qq[i].timeService){if (qq[i].timeService - qq[i].timeCount >= timeSlice){qq[i].timeCount += timeSlice;}else{qq[i].timeCount += (qq[i].timeService - qq[i].timeCount);}}else{if (qq[i].timeFinal == 0){qq[i].timeFinal = timecou;}}}else//时间片大小>= 服务时间{qq[i].timeFinal = timecou; //该进程的完成时间=count}}}}for (int i = 0; i < processNum - 1; ++i){qq[i].timeRound = qq[i].timeFinal - qq[i].timeArrive;qq[i].timeRightRound = (float)qq[i].timeRound / qq[i].timeService;}}void ProOutPut2(){ //获取进程处理后的信息printf("进程名\t 到达时间服务时间完成时间周转时间带权周转\n");for (int i = 0; i < processNum - 1; i++){printf(" %c\t\t%d\t %d\t %d\t %d\t %.2f\n", qq[i].data, qq[i].timeArrive, qq[i].timeService, qq[i].timeFinal, qq[i].timeRound, qq[i].timeRightRound);}}int_tmain(int argc, _TCHAR* argv[]){scanfData();ProOutPut1();CalculatetimeFinal();printf("\n");printf("CPU处理中......\n");printf("完成时间:");for (int i = 0; i < processNum - 1; i++){ printf("%d,", qq[i].timeFinal);}printf("\n");printf("周转时间:");for (int i = 0; i < processNum - 1; i++){ printf("%d,",qq[i].timeRound);}printf("\n");printf("带权周转时间:");for (int i = 0; i < processNum - 1; i++){ printf("%.2f,", qq[i].timeRightRound); }printf("\n");ProOutPut2();return 0;}。
时间片轮转调度算法
(1)一设计要求:编写一程序,可以创建若干个虚拟进程,并对若干个虚拟进程进行调度,调度策略为时间片轮转。
要求:进程的个数,进程的内容(即进程的功能序列)来源于一个进程序列描述文件,另外调度运行结果输出到一个运行日志文件。
二设计目的:熟悉进程调度、设计内容:1.设计PCB适用于轮转法;2.建立进程队列;三虚拟程序的描述:虚拟指令的格式:操作命令操作时间● C :表示在CPU上计算● I :表示输入● O :表示输出● W :表示等待● H :表示进程结束操作时间代表该操作命令要执行多长时间。
这里假设I/O设备的数量没有限制,I和O 设备都只有一类。
I,O,W三条指令实际上是不占有CPU的,执行这三条指令就应该将进程放入对应的等待队列(INPUT等待队列,OUTPUT等待队列,WAIT等待队列)。
例如有一虚拟程序p1.prc描述如下:C 30O 12C 9I 14H 0................程序部分代码如下:enum InstructionSet {INPUT,OUTPUT,WAIT,HALT,CALC};//指令类class CInstruction{friend class COsTestDlg;friend class PCB;public:CInstruction(){}~CInstruction(){}CInstruction(InstructionSet iid,int rt){m_nInstructionID=iid;m_nRunTime=rt;}private:CInstruction* m_pNextInstruction;//用于链接一个进程的所有指令成为链表(指令序列)int m_nRunTime;//本指令需要运行的时间长度(定时器时间间隔的个数)InstructionSet m_nInstructionID;//指令类型标识};//进程控制块类class PCB{friend class COsTestDlg;public:PCB(){m_nPID=0;m_csProcessName="";m_nRemainedTime=0;//m_pRuningInstruction=NULL;m_pInstructionList=NULL;m_pNextPCB=NULL;}//构造或创建一个进程PCB(int pid,CString pname){m_nPID=pid;m_csProcessName=pname;m_nRemainedTime=0;//m_pRuningInstruction=NULL;m_pInstructionList=NULL;m_pNextPCB=NULL;}~PCB(){CInstruction* pTemp;while(m_pInstructionList){m_pInstructionList=m_pInstructionList->m_pNextInstruction; pTemp=m_pInstructionList;delete pTemp;}}//本进程添加一条指令void AppendInstruction(CInstruction* pInstruction){CInstruction* pTempInstruction;if(m_pInstructionList==NULL){//emptym_pInstructionList=pInstruction;}else{//more than one nodepTempInstruction = m_pInstructionList;while(pTempInstruction->m_pNextInstruction!=NULL) pTempInstruction=pTempInstruction->m_pNextInstruction; pTempInstruction->m_pNextInstruction=pInstruction;}}private:PCB* m_pNextPCB; //进程队列的指针int m_nPID; //进程标识符CString m_csProcessName; //进程名字int m_nRemainedTime; //当前运行指令运行还需要的时间CInstruction* m_pRuningInstruction; //指向正在运行或将要运行的指令CInstruction* m_pInstructionList; //指向本进程的指令序列(线性表)的第一条指令};PCB* m_pReadyPCBs;//就绪队列PCB* m_pBackupReadyPCBs;//后备就绪队列PCB* m_pInputWaittingPCBs;//输入等待队列PCB* m_pOutputWaittingPCBs;//输出等待队列PCB* m_pPureWaittingPCBs;//其他等待队列int m_nTimeSlice;//时间片大小(定时器时间间隔的倍数)void LoadPCBs(CString csFileName);//从文件中加载要试验的进程信息void RemoveProcess(PCB* pPCB);//删除进程void DoSchedule();void RunOneTimeRange(PCB* pPCB,int nTime);//运行一个时间段void TreadWaittingQueue(PCB* pWaittingPCBs);//处理某个等待队列,适时将完成进程移出到后备就绪队列。
操作系统课程设计——CPU时间片轮转算法
目录一、设计目的 (1)二、设计内容 (1)三、设计原理 (2)四、算法实现 (2)五、流程图 (4)六、源程序 (5)七、运行示例及结果分析 (14)八、心得体会 (16)九、参考资料 (17)时间片轮转法进行CPU调度一、设计目的处理机调度是操作系统中非常重要的部分。
为深入理解进程管理部分的功能,设计时间片轮转法进行CPU调度算法,模拟实现处理机的调度。
通过本次课程设计理解进程调度的概念,深入理解进程控制的功能、进程的创建与删除以及进程各个状态之间的转换过程,实现时间片轮转算法调度进程。
1、学会使用C++语言编写和调试一个简单的时间片轮转法进行CPU调度的程序。
2、加深了解有关进程控制块和进程队列的概念。
3、并体会时间片轮转算法的具体实现方法。
二、设计内容用时间片轮转算法模拟单处理机调度。
(1)建立一个进程控制块PCB来代表。
PCB包括:进程名、链接指针、到达时间、估计运行时间、剩余时间和进程状态。
进程状态分为就绪(P)、运行(W)和完成(F)。
(2)为每个进程任意确定一个要求运行时间和到达时间。
(3)按照进程到达的先后顺序排成一个循环队列。
再设一个对首指针指向第一个到达进程的首址。
(4)执行处理机调度时,开始选择对首的第一个进程运行。
另外再设一个当前运行进程的指针,指向当前正运行的进程。
(5)执行: a)预计运行时间减1;b)输出当前运行进程的名字。
(6)进程执行一次后,若该进程的剩余运行时间为零,则将该进程的状态置为完成态F,并退出循环队列;若不为空,则将其移至队尾。
继续在运行队首的进程。
(7)若就绪队列不空,则重复上述的(5)和(6)步骤直到所有进程都运行完为止。
在所设计的调度程序中,要求包含显示或打印语句。
以便显示或打印每次选中进程的名称及运行一次后队列的变化情况。
三、设计原理在早期的时间片轮转法中,系统将所有的就绪进程按先来先服务的原则排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片。
操作系统课程设计-时间片轮转算法java实现
学校代码: 10128学号: 201020205056之迟辟智美创作课程设计题目:处置机管理模拟系统的设计与实现学生姓名:学院:信息工程学院系别:软件工程系专业:软件工程班级:指导教师:副教授讲师2013年1月8日内蒙古工业年夜学课程设计任务书(四)学院(系):信息学院软件工程系课程名称:把持系统课程设计指导教师(签名):专业班级:学生姓名:学号:摘要把持系统是计算机系统的关键组成部份,负责管理与配置内存、决定系统资源供需的优先次第、控制输入与输出设备、把持网络与管理文件系统等基本任务.对分歧的系统和系统目标,通常采纳分歧的调度算法,如在批处置系统中,为照顾为数众多的短作业,采纳短作业优先调度算法;在分时系统中,为保证系统具有合理的响应时间,采纳时间片轮转法进行调度.采纳算法时,则要考虑多方面因素,以便达到最佳效果.本次课程设计采纳时间片轮转调度算法来实现模拟进程调度任务的执行过程.用Java模拟进程调渡过程,可以方便地将运行结果直观地暗示出来.Java语言独占的多线程把持,可以实现许多其他语言不能实现的功能,极年夜处所便了法式开发人员对法式的开发.另外,利用JavaGUI编程,可以使系统提供的界面更加友好.实验中,应用文件I/O把持、线程、AWT、Swing、内部类、接口、异常处置等技术,开发此系统.关键字:时间片轮转;Java编程;GUI图形用户界面;文件把持;AbstractThe operating system is a key component of the computer system, responsible for the management and configuration memory, decided to system resources supply and demand priority, control input and output equipment, operation and management of network file system, and other basic tasks.For different systems and system target, computers usually use different scheduling algorithm, such as in a Batch Processing System, in order to take care of a lot of short operation, using Short JobFirst algorithm;In systems with time sharing, to ensure the system has reasonable response time, needtime slice Round Robin algorithm for scheduling. The algorithm, we should consider various factors, in order to achieve the best effect.This Course Design uses time slice Round Robin algorithm to simulate the process scheduling task execution process.With Java simulation process scheduling process, which can be conveniently will run results intuitively said out.In addition, the use of JavaGUI programming, can make the system to provide the interface more friendly.Experiments, application file I/O operation, threads, AWT, Swing, internal class, interface, abnormal processing technology, the development of this system.Keywords:time slice Round Robin; Java Programming;GraphicalUserInterface;File Operation;目录第一章问题分析 ---------------------------------------------------------- 1第二章概要设计 ---------------------------------------------------------- 3第三章详细设计 ---------------------------------------------------------- 53.2.1系统框架接口run()73.2.3创立进程接口createFrame()83.2.4运行法式接口runFrame() -------------------------------- 83.2.5显示结果接口resultFrame()9第四章系统实现 --------------------------------------------------------- 11第五章自我评价与总结 ------------------------------------------------ 16参考文献 ------------------------------------------------------------------- 17第一章问题分析在多道法式或多任务系统中,系统同时处于就绪态的进程有若干个.也就是说能运行的进程数远远年夜于处置机个数.为了使系统中的各进程能有条不紊地运行,必需选择某种调度战略,以选择一进程占有处置机.要求设计一个模拟单处置机调度的算法,以巩固和加深处置机调度的概念.问题描述处置机管理是把持系统中非常重要的部份.为深入理解处置机调度部份的功能,设计一个按时间片轮转调度CPU的算法,模拟实现处置机的调度.基本要求时间片轮转调度CPU的算法是分时系统采纳的典范算法,把CPU的执行时间分成若干个一定年夜小的时间片轮流的分配给就绪队列的各个进程,让各就绪进程按指定的顺序分别占用CPU的一个时间片轮流执行下去,直至完成.要求界说进程控制块PCB的结构,并为每个进程任意确定一个要求运行时间和达到时间,依照进程达到的先后顺序排成一个循环队列.设计按时间片轮转的进程调度算法.a.设计思想(1) 假设系统有5个进程,每个进程用一个进程控制块Process来代表.Process 的结构如图1-1所示.对PCB控制块进行包装,形成循环链表结点ProcessNode,链表结点ProcessNode如图1-2所示.(2) 为每个进程从模拟的系统中指定一个要求运行时间和达到时间.(3) 依照进程达到的先后顺序排成一个循环队列,再设一个队首指针head指向第一个达到进程的首址.(4) 执行处置机调度时,从队列的第一个进程开始,用pntmp指针顺序选择可执行的进程执行.(5) 由于本实践是模拟算法,所以对被选中进程其实不实际启动运行,而只是执行:运行时间加100和输出以后运行进程的相关信息.用这两个把持来模拟进程的一次运行.b.运行环境编程语言:Java语言第二章概要设计系统结构条理图图2-1处置机管理系统条理图系统功能说明a.创立进程模块:创立进程模块在输入进程页面输入要创立的进程数,输入后逐个将进程信息录入拔出到就绪队列中,完成进程的创立过程.b.运行法式模块:此模块实现时间片轮转调度算法,从就绪队列中取出进程结点,并模拟运行该进程,反复循环,直至进程全部运行结束.每次运行进程后,将运行信息存入到文件中,实现信息的耐久化.方便信息的记录,系统功能的分析和犯错时便于检查毛病.c.显示结果模块:从文件中读入进程运行的结果,在图形界面下把持,提供友好的用户把持方式,方便直观的了解模拟进程的调渡过程,便于数据分析和研究.a.在创立进程界面将进程信息录入,将进程控制块进行包装,拔出到循环队列中;b.当运行法式时,每次从就绪队列队首取出一个进程pntmp,判断是pntmp进程否达到.达到则运行该进程;c.若pntmp进程为首次运行,则记录进程开始运行时间startTime;d.运行完pntmp进程后,输出进程运行信息,并将此结点移至队尾;e.若循环队列长度size>0,则返回执行b;否则结束法式;第三章详细设计图3-1法式流程图3.2.1系统框架接口run()publicvoid run(){//创立系统主页的框架}3.2.2增加面板组件接口addComponentsTpPane()publicstaticvoid addComponentsTpPane(Container pane){//4.监听按钮举措,并发生相应把持,执行对应的功能}createFrame()publicstaticvoid createFrame(){class createInputFrame extends Frame implements ActionListener{ //局部内部类实现创立进程的界面//窗体按钮等属性的界说public createInputFrame(String str){ //创立进程输入窗口}void panelCreateProIndex(){ //进程输入首页面}void panelCreateProInput(){ //进程信息输入页面}publicvoid actionPerformed(ActionEvent e) {//监听器}}createInputFrame cf=new createInputFrame("进程创立");//实例化}runFrame()publicstaticvoid runFrame(){int currenttime=0; //记录系统以后时间while(size!=0){//2.运行时间片轮转调度算法,并记录信息}try { //3将运行信息存入文件String file="D:\\Java\\Processor\\myfile.txt";} catch (IOException e1) {}}resultFrame()publicstaticvoid resultFrame(){JFrame jf=new JFrame("显示运行结果");final JTextArea jta=new JTextArea(16,50);openbutton.addActionListener(new ActionListener(){ publicvoid actionPerformed(ActionEvent e) {}});}用户启动此处置机管理模拟系统后,即可方便的进行把持.以下为用户使用此软件时的图形接口:c.系统主界面(图3-2):d.进程创立页面(图3-3):图3-2图3-3第四章系统实现系统采纳高级语言Java设计实现,法式容易阅读,易于测试,容易调试,方便维护.而且Java为现今最流行的编程语言,有其独到的优点;法式代码符合基本编程规范,方法,属性命名能体现法式的功能.d.测试数据进程数num: 2进程名进程运行时间进程达到时间神舟1号800 0神舟2号300 100e.预期输出无输出结果,但创立进程模块将输入数据存入内存,并结束输入返回主界面.f.运行结果①进程数输入界面(图4-1):图4-1②进程信息输入界面(图4-2):③测试数据进程数num:2进程名进程运行时间进程达到时间神舟1号800 0神舟2号300 100④预期输出系统时间进程名剩余时间已运行次数进程状态周转时间 0 神舟1号700 1 true100200 神舟1号600 2 true300 神州2号200 1 true图4-2400 神舟1号500 3 true500 神州2号100 2 true600 神舟1号400 4 true700 神州2号100 3 false 700800 神舟1号300 5 true900 神舟1号200 6 true1000 神舟1号100 7 true1100 神舟1号100 8 false 1200⑤运行结果(图4-3)图4-35.测试数据无需测试数据6.预期输出文件正常翻开,在终端显示相关控制信息及内容;在用户界面显示文件内进程运行时的信息内容及运行的结果;合法的输出;7.运行结果(图4-4)图4-41)规划管理器实现页面规划时,不能很好的显示在桌面上.对GridLayout,FlowLayout,BorderLayout,CradLyaout等规划管理器还不是很熟悉.2)对系统结构的划分不妥,没有实现界面和数据处置的分离;3)对用户的非法把持做了处置,但并没有完全找出处置毛病把持的方法;4)没有充沛理解将要设计的系统结构,系统条理结构不够清晰;第五章自我评价与总结通过本次课程设计,我对把持系统中的处置机的调度算法有了进一步的理解.在对时间片轮转算法进行设计实现的过程中,自己同时也自学了JavaGUI编程,对图形用户界面编程从理论上的认识走向了亲身实践.只有亲自入手编程才华对所学到的内容有深刻的理解,所谓“实践出真知”.此处置机管理模拟系统能够方便直观地显示出基于时间片轮转调度算法的模拟调渡过程,方便了该系统用户的处置机调度算法的学习和研究实验过程中,查阅了年夜量的JavaAPI相关文档和处置机调度模拟算法,最终形成自己的思路,完成了系统的功能界说和编码测试.尤其是在编码测试环节,配合控制台的显示功能,能及时发现法式中的毛病,处置异常和法式的逻辑毛病.在整个课程设计过程中,先后学习新的知识并巩固了已学到的进程调度,文件把持,异常处置机制,Java的高级类特性,面向对象法式设计,线程把持的相关技术和知识.另外,编写处置机管理模拟系统相关文档也使我对规范化编码和书写相关说明文档进一步规范和熟练.在实验过程中也遇到了许多的问题,有的至今也没有找出好的解决方案.例如,自己过早的急于编码实现,造成了系统的结构条理不够清晰,系统界面与系统功能的实现为实现分离,为以后设计实现软件提供了很好的警示作用.短短一周的课程设计,我学到了用java编码实现自己从未做过的一些实践,提高了自己的入手能力,反复修改代码的过程中提高了自己自力思考问题的能力.在此特别感谢各位老师的指导,有了老师们的支持,才会使我更加圆满的完成此次课题的设计.不懈的努力使自己向实用型人才更迈进了一步,增加自己的实力,增加了自己的竞争力.参考文献1>java API 文档《JDK_API_1.6.0_CN.CHM》;2>赵俊生、马志强著《内蒙古工业年夜学课程设计说明书书写规范》2013年1月3>刘中兵著《Java高手真经(编程基础卷:Java核心编程技术)》北京:电子工业出书社2009年3月4>郑莉王行言马素霞著《Java语言法式设计》北京:清华年夜学出书社 2010年7月5>张尧学著《计算机把持系统教程(第三版)》北京:清华年夜学出书社,2006年6>汤子瀛主编《计算机把持系统(第三版)》西安:西安电子科技年夜学出书社,2001年7>王鹏等编《零基础学Java》北京:机械工业出书社 2008年1月。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
一、实验目的本课程设计以Windows操作系统为实验平台,进行源代码分析和修改。
通过该课程设计,使学生掌握Windows操作系统各部分结构、实现机理和各种典型算法;系统地了解操作系统的设计和实现思路,运用内核开发环境实现对内核的修改,培养学生的系统设计能力,并了解操作系统的发展动向和趋势。
二、实验内容1.分析设计内容,给出解决方案(要说明设计实现的原理,采用的数据结构)。
2.画出程序的基本结构框图和流程图。
3.对程序的每一部分要有详细的设计分析说明。
4.源代码格式要规范。
5.设计合适的测试用例,对得到的运行结果要有分析。
6.设计中遇到的问题,设计的心得体会。
7.按期提交完整的程序代码、可执行程序和课程设计报告。
三、实验步骤1、任务分析:时间片轮转的主要思想就是按顺序为每一个进程一次只分配一个时间片的时间。
算法要完成的功能就是将各个进程按照时间片轮转运行的动态过程显示出来。
时间片轮转算法的主要实现过程是首先为每一个进程创建一个进程控制块,定义数据结构,说明进程控制块所包含的内容,有进程名、进程所需运行时间、已运行时间和进程的状态以及指针的信息。
实现的过程即运用指针指向某一个进程,判断当前的进程是否是就绪状态“r”,如果是,则为该进程分配一个时间片,同时,已运行时间加一且要求运行的时间减一,如此循环执行,当某一个进程的所需要运行的时间减少至0时,则将该进程的状态设置为“e”。
然后,将指针指向下一个未运行完成的进程,重复判断,直至所有的进程都运行结束。
2、概要设计:(1)所用数据结构及符号说明typedef struct PCB{c har name[10];先建立PCB的数据结构,为了便于正确输出,加上了进程结束标志flag。
输入进程信息(包括进程名和要求运行的时间),并为每个进程创建一个PCB并初始化形成一个循环链队列,用函数creatPCB()来实现。
b.建立函数judge()用来判断进程全部运行结束标志,即当所有进程的状态变为’e’(即完成状态)后,循环结束,表示所有进程都已运行成功。
c.建立时间片轮转算法creatProcess()对进程进行轮转运行,首先指针s指向第一个进程PCB,即s=front,判断该进程的状态是否为’r’(就绪状态),即if(s->condition == 'r'),若是则表示此进程尚未执行结束,则执行s->worked_time++且s->need_time--,if(s->need_time==0),则表示此进程已运行结束,将其状态置为结束,即s->condition='e',并根据状态位输出完成信息,且以后不会再运行此进程。
将指针指向下个进程,s=s->next,并判断所有进程是否已全部运行结束,没有则重复上面算法。
当所有进程的状态位都变成’e’表示所有进程运行完成,则循环结束。
d.建立主函数main(),输入进程数N,调用初始化循环链队列函数creatPCB()和时间片轮转算法creatProcess(N),每次选中进程的进程名以及运行一次后进程队列的变化,实现处理器的调度。
4、调试分析:a.调试过程中遇到的问题及解决方案开始运行到Q5运行完成后显示错误,如下图所示:原因:经检查程序发现语句if(s->condition=='e' ){printf("进程%s已经运行完成!\n\n",s->name);}有错误,因为当某个进程运行完成后,其状态标志已修改为’e’,所以再次循环运行未完成的进程时,当运行到此句时仍会将前面已完成的进程重新输出一遍完成信息,导致输出错误。
解决方案:为每个进程加上一个结束标志flag,并赋初值为0,当进程运行完成后,将flag改为1,再将后面输出改为if(s->condition=='e' || s->flag==0 ){printf("进程%s已经运行完成!\n\n",s->name);s->flag==0;},这样在前面进程运行完成输出后,后面再循环时就不会重新输出一遍了。
b.改进设想:本实验较简单,但还不够完善,如未实现插入进程功能,即进程在运行过程中可以插入其他的进程再运行。
还有未进行进程优先级判别,本实验默认进程的优先级按输入的先后顺序从大到小排列的,还有其他功能等,希望在以后的实验中逐步完善。
5、测试结果:a.首先输出五个进程的初始状态b.开始从进程Q1开始按时间片轮转运行进程,Q4先运行完成c.接着Q1运行完成d.接着Q5运行完成e.再Q3运行完成f.最后Q2运行完成四、实验总结因在早期的时间片轮转法中,系统将所有的就绪进程按照先来先服务的原则排成一个队列,每次调度是,把CPU分配给队首进程,并令其执行一个时间片。
当执行的时间片用完时,调度程序停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。
在时间片轮转算法中,时间片的大小对系统性能有很大的影响。
如果选择很小的时间片将有利于短作业,因为它能较快地完成,但会频繁的发生中断、进程上下文的切换,从而增加系统的开销;反之,如果选择太长时间片,使得每个进程都能在一个时间片内完成,所以,一般定为时间片略大于一次典型地交互所需要的时间。
在完成时间片轮转算法的实现过程中,我们遇到了一些问题,比如怎样运用循环队列,如何设计结构体等等,也积极配合并思考进行解决。
整体来说,我们的算法虽然实现了体现进程动态运行变化的过程,但是相对而言比较简单。
实验中,我们小组不断讨论对算法进行优化,使得运行结果看起来更容易理解,也达到了处理机调度的功能。
做实验让我们对于时间片轮转的思想理解的更加透彻,巩固了理论知识的学习。
实验心得体会:首先,我们认为这次课程设计是对学习《操作系统》的一次综合考察,锻炼我们综合分析问题、解决问题的能力。
初次得到课程设计的题目时,为程序本身的简单而窃喜过;实验过程中也出现了一些难题需要解决,为此去苦苦探索过。
课程设计期间,几乎有几天我们完全投入进去了,就像是在做一个相当重要的项目一样的感觉。
曾经跑过图书馆几次,只是为了一种新的想法得到实现,也曾多次登录网站浏览网页,为了弥补一些知识上的纰漏,为此曾洒下了真实的汗水。
当我们的想法得到实现,又学会了新的知识的时候,心中满是欣喜,或许这是实践出真知的真实验证,有付出就有回报的真实写照吧。
其次,我们感受了真诚的友谊。
在实验中,遇到的问题是多方面的,而且有那么一部分是以前学过的C问题,但是已经忘却或是以前没有真正的理解过。
但是你会发现就在你的身边,会有那么一批人在背后热心的帮助你,让你身处困境却感到无限希望。
这好像是人生的一种历程,风风雨雨中我们一起走过,然后为了一些坑坑洼洼彼此真诚的帮助过和无私的付出过。
团队的协作和彼此心的交流让我们彼此丰厚起来,这也是我们成长中必不可失的重要部分。
最后,我认识到了自己的不足。
平心而论,以前真的没有认真的学习过,即使是在听课,可是后来却没有对学习中出现的问题而仔细分析过。
得过且过,迷失了我前进的方向,而现在却又重新敞开了。
不论是以后的学习还是工作,我想这都是很重要的,我们需要不断进步的动力。
总的说来知识上的收获很是重要,精神上的丰收也是更加可喜的,让我知道了学无止境的道理。
我们每一个人永远不能满足于现有的成就,人生就像在爬山,一座山峰的后面还有更高的山峰在等着你。
挫折是一份财富,经历是一份拥有。
这次课程设计必将成为我人生旅途上一个非常美好的回忆。
五、源程序实验源程序如下:#include""#include""#include""#include""#define NULL 0typedef struct PCB{char name[10]; //进程名struct PCB *next; //链指针int need_time; //要求运行时间int worked_time; //已运行时间char condition; //进程状态,只有"就绪"和"结束"两种状态int flag; //进程结束标志}PCB;PCB *front,*rear;int N; //N为进程数void creatPCB(){ //为每个进程创建一个PCB并初始化形成一个循环链队列PCB *p,*l;l = (PCB *)malloc(sizeof(PCB));printf("请输入各进程名和要求运行时间\n");scanf("%s%d",l->name,&l->need_time);l->condition = 'r'; //进程初始状态为就绪l->worked_time = 0;l->next=NULL;l->flag=0;front=l;for(int i = 1;i < N ;i ++){p = (PCB *)malloc(sizeof(PCB));scanf("%s%d",p->name,&p->need_time);p->condition = 'r';p->worked_time = 0;p->flag=0;l->next = p;l=l->next;}rear=l;rear->next=front;}void output(){ //进程输出函数printf("进程名已运行时间需要时间状态\n");for(int j=1;j<=N;j++){printf(" %-4s\t %-4d\t %-4d\t%-c\n",front->name, front->worked_time, front->need_time, front->condition);front=front->next;}printf("\n");}int judge(PCB *p){ //判断所有进程运行结束int flag = 1;for(int i=0;i<N;i++){if(p->condition != 'e'){flag = 0;break;}p=p->next;}return flag;}void creatProcess(int n){ //时间片轮转算法PCB *s,*p;int i,j,flag1=0;s = (PCB *)malloc(sizeof(PCB));s=front;printf("\n--------------------------------------------\n");output();printf("请按任意键继续\n\n");getch(); //按任意键继续s=front;while(flag1 != 1){if(s->condition == 'r'){s->worked_time++;s->need_time--;if(s->need_time==0)s->condition='e';output();printf("请按任意键继续\n\n");getch();}if(s->condition=='e' && s->flag==0){printf("进程%s已经运行完成!\n\n",s->name);s->flag=1;}s=s->next;flag1=judge(s);}printf("--------------------------------------------\n"); }void main(){printf("请输入进程总数\n");scanf("%d",&N);creatPCB();creatProcess(N);}。