时间片轮转算法课程设计

合集下载

时间片轮转算法课程设计

时间片轮转算法课程设计

一、实验目的本课程设计以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’(即完成状态)后,循环结束,表示所有进程都已运行成功。

操作系统实验二报告-时间片轮转进程调度算法1

操作系统实验二报告-时间片轮转进程调度算法1

操作系统实验报告实验二时间片轮转进程调度算法学号:班级:姓名:【实验题目】: 时间片轮转进程调度算法【实验目的】通过这次实验, 加深对进程概念的理解, 进一步掌握进程状态的转变、进程调度的策略与对系统性能的评价方法。

【实验内容】问题描述:设计程序模拟进程的时间片轮转RR 调度过程。

假设有n 个进程分别在T1, … ,Tn 时刻到达系统, 它们需要的服务时间分别为S1, … ,Sn 。

分别利用不同的时间片大小q, 采用时间片轮转RR 进程调度算法进行调度, 计算每个进程的完成时间, 周转时间和带权周转时间, 并且统计n 个进程的平均周转时间和平均带权周转时间。

程序要求如下:1)进程个数n ;每个进程的到达时间T 1, … ,T n 和服务时间S 1, … ,S n ;输入时间片大小q 。

2)要求时间片轮转法RR 调度进程运行, 计算每个进程的周转时间, 带权周转时间, 并且计算所有进程的平均周转时间, 带权平均周转时间;3)输出: 要求模拟整个调度过程, 输出每个时刻的进程运行状态, 如“时刻3: 进程B开始运行”等等;4)输出:要求输出计算出来的每个进程的周转时间, 带权周转时间, 所有进程的平均周转时间, 带权平均周转时间。

实现提示:用C++语言实现提示:1)程序中进程调度时间变量描述如下:int ArrivalTime[100];int ServiceTime[100];int PServiceTime[100];int FinishTime[100];int WholeTime[100];double WeightWholeTime[100];double AverageWT,AverageWWT;bool Finished[100];➢2)进程调度的实现过程如下:➢变量初始化;➢接收用户输入n, T1, … ,Tn, S1, … ,Sn;时间片大小q;➢按照时间片轮转RR算法进行进程调度, 计算进程的完成时间、周转时间和带权周转时间;➢计算所有进程的平均周转时间和平均带权周转时间;➢按格式输出调度结果。

操作系统课程设计——CPU时间片轮转算法

操作系统课程设计——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分配给队首进程,并令其执行一个时间片。

计算机操作系统时间片循环轮转算法

计算机操作系统时间片循环轮转算法
int rou nd=0; //记录轮转数
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)每次运行所设计的进程调度程序前,为每个进程任意确定它的“要求运行时间”。

时间片轮转调度算法

时间片轮转调度算法

(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);//处理某个等待队列,适时将完成进程移出到后备就绪队列。

计算机操作系统时间片循环轮转算法

计算机操作系统时间片循环轮转算法

计算机操作系统时间片循环轮转算法实验报告书课程名:«计算机操作系统»题目:时间片循环轮转调度班级:软件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分配给队首进程,并令其执行一个时间片。

时间片轮转算法

时间片轮转算法
b.改进设想:本实验较简单,但还不够完善,如未实现插入进程功能,即进程在运行过程中可以插入其他的进程再运行。还有未进行进程优先级判别,本实验默认进程的优先级按输入的先后顺序从大到小排列的,还有其他功能等,希望在以后的实验中逐步完善。
5、测试结果:
a.首先输出五个进程的初始状态
b.开始从进程Q1开始按时间片轮转运行进程,Q4先运行完成
printf("进程%s已经运行完成!\n\n",s->name);
s->flag=1;
}
s=s->next;
flag1=judge(s);
}
printf("--------------------------------------------\n");
}
void main(){
printf("Please enter process number\n");
c.接着Q1运行完成
d.接着Q5运行完成
e.再Q3运行完成
f.最后Q2运行完成
四、实验总结
因在早期的时间片轮转法中,系统将所有的就绪进程按照先来先服务的原则排成一个队列,每次调度是,把CPU分配给队首进程,并令其执行一个时间片。当执行的时间片用完时,调度程序停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。在时间片轮转算法中,时间片的大小对系统性能有很大的影响。如果选择很小的时间片将有利于短作业,因为它能较快地完成,但会频繁的发生中断、进程上下文的切换,从而增加系统的开销;反之,如果选择太长时间片,使得每个进程都能在一个时间片内完成,所以,一般定为时间片略大于一次典型地交互所需要的时间。

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

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

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

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

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

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

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

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

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

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

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

(时间管理)用时间片轮转法调度虚拟进程

(时间管理)用时间片轮转法调度虚拟进程
myfile<<p->count<<"";myfile<<p->round<<"";myfile<<p->state<<endl;
}
voidprt(charalgo)
{
PCB*p; prt1(algo);if(run!=NULL)
{
prt2(algo,run);
}
p=ready;while(p!=NULL)
每个进程有壹个进程控制块(PCB)表示。进程控制块能够包含如下信息:进程名、优先数、到达时间、需要运行时间、已用 CPU 时间、进程状态等等。
进程的优先数及需要的运行时间能够事先人为地指定(也能够由随机数产生)。进程的到达时间为输入进程的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态能够是就绪W(Wait)、运行R(Run)、或完成F(Finish)三种状态之壹。
{
PCB*p;intn,time; charna[10];ready=NULL;finish=NULL; run=NULL;
cout<<"请输入进程数目N:";cin>>N;
for(n=0;n<N;n++)
{
p=(PCB*)malloc(sizeof(PCB));cout<<"Enterthenameofprocess:"<<endl;cin>>na; cout<<"Enterthetimeofprocess:"<<endl; cin>>time;

时间片轮转调度算法设计与实现

时间片轮转调度算法设计与实现

郑州轻工业学院实验报告课程名称:操作系统姓名:学号:专业班级:任课教师:黄伟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

操作系统课程设计报告-基于时间片的轮转调度算法[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算法[整理版]

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-2种调度算法;能够输⼊进程的基本信息,如进程名、提交时间、预估运⾏时间等;根据选择的调度算法显⽰进程调度顺序;显⽰完成调度后每个进程的开始时间、完成时间呢、周转时间,带权周转时间;计算平均周转时间和平均带权周转时间;三、实验过程1、设计思想系统将所有的就绪进程按FCFS策略排成⼀个就绪队列。

系统可设置每隔⼀定时间(如30ms)便产⽣⼀次中断,去激活进程调度程序进⾏调度,把CPU分配给队⾸进程,并令其执⾏⼀个时间⽚。

当它运⾏完毕后,将进程管道就绪队列的队尾,再把处理机分配给就绪队列中新的队⾸进程,也让它执⾏⼀个时间⽚,以此类推。

这样,就可以保证就绪队列中的所有进程在确定的时间段内,都能获得⼀个时间⽚的处理机时间。

将进程按FCFS排成⼀个队列,每次调度取队⾸进程分配CPU,时间⽚到,将PCB挂到就绪队尾。

在时间⽚轮转调度算法中,应在何时进⾏进程的切换,可分为两种情况:① 若⼀个时间⽚尚未⽤完,正在运⾏的进程便已经完成,就⽴即激活调度程序,将它从就绪队列中删除,再调度就绪队列中队⾸的进程运⾏,并启动⼀个新的时间⽚。

② 在⼀个时间⽚⽤完时,计时器中断处理程序被激活。

如果进程尚未运⾏完毕,调度程序将把它送往就绪队列的末尾。

2.运⾏结果四、实验代码public class Thread {int id;//进程IDint arrivetime;//到达时间int runtime;//运⾏时间int rmaintime;//剩余运⾏时间int endtime;//完成时间int turnovertime;//周转时间float qturnovertime;//带权周转时间public int getId() {return id;}public void setId(int id) {this.id = id;}public int getArrivetime() {return arrivetime;}public void setArrivetime(int arrivetime) {this.arrivetime = arrivetime;}public int getRuntime() {return runtime;}public void setRuntime(int runtime) {this.runtime = runtime;}public int getRmaintime() {return rmaintime;}public void setRmaintime(int rmaintime) {this.rmaintime = rmaintime;}public int getEndtime() {return endtime;}public void setEndtime(int endtime) {this.endtime = endtime;}public int getTurnovertime() {return turnovertime;}public void setTurnovertime(int turnovertime) {this.turnovertime = turnovertime;}public float getQturnovertime() {return qturnovertime;}public void setQturnovertime(float qturnovertime) {this.qturnovertime = qturnovertime;}public Thread() {id=0;arrivetime=0;//到达时间runtime=0;//运⾏时间rmaintime=0;//剩余运⾏时间endtime=0;//完成时间turnovertime=0;//周转时间qturnovertime=0;//带权周转时间}public Thread(int id, int arrivetime, int runtime,int rmaintime) { this.id = id;this.arrivetime = arrivetime;this.runtime = runtime;this.rmaintime=rmaintime;}@Overridepublic String toString() {return "Thread{" +"id=" + id +", arrivetime=" + arrivetime +", runtime=" + runtime +", rmaintime=" + rmaintime +'}';}}package com.hu;import java.util.Iterator;import java.util.LinkedList;import java.util.Random;public class Test {static final int slicetime=2;//时间⽚⼤⼩设为2public static void main(String[] args) {RR(InitQueue(SortThread(InitThread())));}public static void RR(LinkedList queue){int i=0;int count=0;for (Iterator iter = queue.iterator(); iter.hasNext();){System.out.println();Thread thread =(Thread) queue.getFirst();System.out.println(thread);if (thread.rmaintime<=slicetime){count=count+thread.rmaintime;//当前时间thread.endtime=count;//结束时间thread.turnovertime= thread.endtime-thread.arrivetime;//周转时间thread.qturnovertime=(float)thread.turnovertime/thread.runtime;//带权周转时间thread.rmaintime=0;System.out.println(thread.getId()+"号进程结束"+"结束时间:"+thread.endtime+"周转时间:"+thread.turnovertime+"带权周转时间:"+thr ead.qturnovertime);queue.remove();}else {count=count+2;//当前时间thread.rmaintime=thread.rmaintime-slicetime;//执⾏进程queue.remove();queue.offer(thread);//时间⽚完插⼊队尾}}}public static Thread[] InitThread(){//初始化进程到达时间与运⾏时间Thread[] thread = new Thread[5];for (int i=0;i<thread.length;i++){Random random = new Random();int t= random.nextInt(10)+1;thread[i] = new Thread(i,random.nextInt(10)+1,t,t);}return thread;}public static Thread[] SortThread(Thread[] threads) {//进程排序for (int i = 0; i < threads.length; i++) {for (int j = 0; j < threads.length - 1; j++) {if (threads[j].arrivetime > threads[j + 1].arrivetime) {//如果进程到达时间不相等按进程的到达时间从⼩到⼤排序Thread t;t = threads[j];threads[j] = threads[j + 1];threads[j + 1] = t;}if (threads[j].arrivetime == threads[j + 1].arrivetime) {//如果进程到达时间相等按进程的运⾏时间从⼩到⼤排序if (threads[j].runtime > threads[j + 1].runtime) {Thread t;t = threads[j];threads[j] = threads[j + 1];threads[j + 1] = t;}}}}return threads;}public static LinkedList InitQueue(Thread[] threads){//初始化队列LinkedList<Thread> queue = new LinkedList<Thread>();for (int i=0;i< threads.length;i++){queue.offer(threads[i]);}return queue;}}。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

时间片轮转算法课程设计TYYGROUP system office room 【TYYUA16H-TYY-TYYYUA8Q8-一、实验目的本课程设计以Windows操作系统为实验平台,进行源代码分析和修改。

通过该课程设计,使学生掌握Windows操作系统各部分结构、实现机理和各种典型算法;系统地了解操作系统的设计和实现思路,运用内核开发环境实现对内核的修改,培养学生的系统设计能力,并了解操作系统的发展动向和趋势。

二、实验内容1.分析设计内容,给出解决方案(要说明设计实现的原理,采用的数据结构)。

2.画出程序的基本结构框图和流程图。

3.对程序的每一部分要有详细的设计分析说明。

4.源代码格式要规范。

5.设计合适的测试用例,对得到的运行结果要有分析。

6.设计中遇到的问题,设计的心得体会。

7.按期提交完整的程序代码、可执行程序和课程设计报告。

三、实验步骤1、任务分析:时间片轮转的主要思想就是按顺序为每一个进程一次只分配一个时间片的时间。

算法要完成的功能就是将各个进程按照时间片轮转运行的动态过程显示出来。

时间片轮转算法的主要实现过程是首先为每一个进程创建一个进程控制块,定义数据结构,说明进程控制块所包含的内容,有进程名、进程所需运行时间、已运行时间和进程的状态以及指针的信息。

实现的过程即运用指针指向某一个进程,判断当前的进程是否是就绪状态“r”,如果是,则为该进程分配一个时间片,同时,已运行时间加一且要求运行的时间减一,如此循环执行,当某一个进程的所需要运行的时间减少至0时,则将该进程的状态设置为“e”。

然后,将指针指向下一个未运行完成的进程,重复判断,直至所有的进程都运行结束。

2、概要设计:(1)所用数据结构及符号说明typedef struct PCB{char 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);}。

相关文档
最新文档