时间片轮转RR进程调度算法(华侨大学)

合集下载

2016华侨大学计算机科学与技术操作系统简答题

2016华侨大学计算机科学与技术操作系统简答题

2016华侨大学计算机科学与技术操作系统简答题第一篇:2016华侨大学计算机科学与技术操作系统简答题简答题一、第一章操作系统引论 1.实时系统与分时系统的区别? 1)多路性。

1.实时信息处理系统也按分时原则为多个终端用户服务。

2.实施控制系统的多路性则主要表现在系统周期地对多路现场信息进行采集,以及对多个对象或多个执行机构进行控制。

3.分时系统中的多路性则与用户情况有关,时多时少。

2)独立性1.实时信息处理系统中的每个终端用户在向实时系统提出服务请求时,是彼此独立的操作,互不干扰。

2.实时控制系统中,对信息的采集和对象的控制也都是彼此互不干扰。

3)及时性1.实时信息处理系统对实时性的要求与分时系统类似,都是以人所能接受的等待时间来确定的。

2.实时控制系统的及时性,则是以控制对象所要求的开始截至时间或完成截止时间来确定的。

4)交互性1.实时信息处理系统中,人与系统的交互仅限于访问系统中某些特定的专用服务程序2.分时系统可以向终端用户提供数据处理和资源共享服务。

5)可靠性1.分时系统和实时系统均要求系统可靠,实时系统比分时系统更可靠。

2.操作系统的主要功能1)处理机管理1.进程同步:进程同步的主要任务是为多个进程(含线程)的运行进行协调(两种协调方式)a)进程互斥方式b)进程同步方式2.进程通信:进程通信的主要任务就是用来实现在相互合作的进程之间的信息交换。

3.调度:在传统的操作系统中,包括作业调度和进程调度两步2)存储器管理1.内存分配:分为静态和动态两种方式2.内存保护:主要任务是确保没到用户程序都在自己的内存空间内运行,彼此互不干扰。

3.地址映射:逻辑地址和物理地址4.内存扩充 3)设备管理1.缓冲管理2.设备分配3.设备处理 4)文件管理1.文件存储空间的管理:其主要任务是为每个文件分配必要的外存空间,提高外存的利用率,并能有助于提高问价系统的存取速度.2.目录管理3.文件读写管理与保护 5)操作系统与用户的接口1.用户接口a)联机用户接口 b)脱机用户接口 c)图形用户接口 2.程序接口二、第二章进程管理1.进程的特征:由于程序是不能参与并发执行的,为使其并发执行,应为之配置进程控制块 1)结构特征1.由程序段,相关的数据段和进程控制块(PCB)三部分构成了进程实体。

进程调度算法实验报告

进程调度算法实验报告

进程调度算法实验报告进程调度算法实验报告一、引言进程调度算法是操作系统中的重要组成部分,它决定了进程在CPU上的执行顺序。

合理的进程调度算法能够提高系统的性能和效率,使得多个进程能够公平地共享CPU资源。

本实验旨在通过实际操作和数据分析,探究不同的进程调度算法对系统性能的影响。

二、实验方法1. 实验环境本次实验使用了一台配置较高的计算机作为实验环境,操作系统为Windows 10。

实验中使用了C语言编写的模拟进程调度程序。

2. 实验步骤(1)编写模拟进程调度程序,实现常见的进程调度算法,包括先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)和优先级调度(Priority)。

(2)设计一组测试用例,包括不同执行时间的进程和不同优先级的进程。

(3)运行模拟进程调度程序,记录每个进程的等待时间、周转时间和响应时间。

(4)根据实验结果分析不同进程调度算法的性能差异。

三、实验结果与分析1. 先来先服务(FCFS)调度算法先来先服务调度算法按照进程到达的先后顺序进行调度,即先到达的进程先执行。

实验结果显示,该算法对于执行时间较短的进程表现良好,但对于执行时间较长的进程则存在明显的不公平性。

长作业的等待时间较长,导致整体执行效率较低。

2. 最短作业优先(SJF)调度算法最短作业优先调度算法按照进程执行时间的长度进行调度,即执行时间最短的进程先执行。

实验结果显示,该算法能够最大程度地减少平均等待时间和周转时间,提高系统的执行效率。

然而,该算法对于执行时间较长的进程存在饥饿问题,即长作业可能一直等待短作业的执行,导致长作业的等待时间过长。

3. 时间片轮转(RR)调度算法时间片轮转调度算法将CPU的执行时间划分为固定长度的时间片,每个进程按照轮流执行的方式进行调度。

实验结果显示,该算法能够保证每个进程都能够获得一定的执行时间,提高了系统的公平性。

然而,对于执行时间较长的进程而言,由于需要等待其他进程的轮转,其执行效率相对较低。

时间片轮转调度

时间片轮转调度

时间片轮转调度
简介
时间片轮转调度是一种常见的进程调度算法,通常用于处理多任务系统中的进
程调度。

它的主要特点是每个进程都会分配一个时间片段,当时间片段用完后,系统会自动切换到下一个进程,从而实现多个进程之间的公平共享CPU时间。

原理
时间片轮转调度的原理比较简单。

系统会为每个进程分配一个固定长度的时间片,当进程开始执行时,系统会计时,当时间片用完后,系统会发出时钟中断,此时会触发调度器将CPU分配给下一个进程。

被切换出去的进程会被放到就绪队列
的末尾,等待下次轮到它执行。

优点
1.公平性:每个进程都有机会获得CPU时间,避免某个进程长时间占
用CPU资源而导致其他进程无法执行。

2.响应时间短:由于时间片固定,当进程被切换到时,可以及时响应,
提高系统的交互性。

缺点
1.时间片长短选择问题:如果时间片过短,频繁的切换会增加调度器的
开销;如果时间片过长,可能会导致部分进程长时间占用CPU,降低公平性。

2.公平性问题:虽然时间片轮转调度可以保证每个进程都能获得CPU
时间,但对于一些实时性要求较高的应用来说,可能无法满足其需求。

应用场景
时间片轮转调度适用于对公平性要求较高,但对实时性要求不是特别高的场景,比如多用户系统、批处理系统等。

在这些场景下,时间片轮转调度可以充分利用系统资源,保证每个进程都能得到执行。

总结
时间片轮转调度是一种简单而有效的进程调度算法,通过合理设置时间片长度,可以实现多任务系统中的进程公平调度。

在合适的场景下,时间片轮转调度可以提高系统的整体性能,保证每个进程都能得到执行,从而提高系统的稳定性和可靠性。

时间片轮转调度算法例题详解

时间片轮转调度算法例题详解

时间片轮转调度算法例题详解操作系统是计算机系统中的一个重要组成部分,它负责管理计算机系统的各种资源,协调各种应用程序的运行,保证计算机系统的高效稳定运行。

操作系统中的进程调度是其中的一个重要内容,它决定了进程在CPU上的运行顺序,直接影响到计算机系统的性能。

本文将详细介绍时间片轮转调度算法,并通过例题进行详解。

一、时间片轮转调度算法时间片轮转调度算法是一种基于时间片的进程调度算法,它将CPU时间片分配给各个正在运行的进程,每个进程在一个时间片内运行一定的时间,然后被挂起,等待下一次调度。

如果进程在一个时间片内没有完成运行,那么它将被挂起,等待下一次调度。

这种调度算法适用于多道程序并发执行的情况,可以避免进程长时间占用CPU,保证进程的公平性和响应性。

时间片轮转调度算法的基本思想是将所有就绪进程按照先来先服务的原则排队,每个进程在一个时间片内运行一定的时间,然后被挂起,等待下一次调度。

时间片的大小可以根据系统的负载情况进行调整,一般情况下,时间片的大小为10ms~100ms之间。

当一个进程在一个时间片内运行完成,它将被移到队列的末尾,等待下一次调度。

如果进程在一个时间片内没有完成运行,那么它将被挂起,等待下一次调度。

这样,所有进程都有机会获得CPU时间,避免了某个进程长时间占用CPU的情况。

时间片轮转调度算法的优点是简单易懂,易于实现,可以保证进程的公平性和响应性。

缺点是时间片的大小对系统的性能有较大影响,时间片过小会导致进程切换频繁,影响系统性能;时间片过大会导致进程响应时间增加,影响用户体验。

二、时间片轮转调度算法例题下面通过一个例题来详细介绍时间片轮转调度算法的实现过程。

题目描述:有3个进程P1、P2、P3,它们的运行时间分别为24ms、3ms、3ms,它们的到达时间分别为0ms、0ms、0ms。

时间片大小为4ms。

请计算它们的平均等待时间和平均周转时间。

解题思路:首先,按照到达时间的先后顺序将进程排队。

高响应比优先调度和时间片轮转rr进程调度算法 -回复

高响应比优先调度和时间片轮转rr进程调度算法 -回复

高响应比优先调度和时间片轮转rr进程调度算法-回复高响应比优先调度和时间片轮转RR进程调度算法引言:进程调度算法是操作系统中的重要组成部分,它决定了进程如何被分配和调度执行的顺序。

在操作系统中,有许多不同的进程调度算法可供选择。

本文将介绍两种常用的进程调度算法,分别是高响应比优先调度(HRN)和时间片轮转(Round-Robin,简称RR)算法。

本文将逐步回答关于这两种算法的原理、特点和应用场景等问题,以全面了解它们的工作原理和优势。

一、高响应比优先调度(HRN)算法1.1 原理介绍高响应比优先调度算法是一种动态优先级进程调度算法,它以进程的响应比为优先级判定标准。

响应比定义为等待时间加服务时间除以服务时间,代表了进程对系统资源的需求程度和等待时间的综合考虑。

对于一个长时间等待的进程,其响应比会不断增加,从而提高其优先级,以便及时得到服务。

1.2 特点和优势高响应比优先调度算法的特点和优势主要体现在以下几个方面:- 公平性:通过动态调整进程的优先级,保证了每个进程都有机会得到系统资源的分配。

- 短进程优先:长时间等待的进程会相应地提高其优先级,从而能够更早地得到服务,减少了等待时间。

- 高吞吐量:通过合理地考虑进程的等待时间和服务时间,提高了系统的吞吐量。

- 性能良好:与其他进程调度算法相比,高响应比优先调度算法的性能较好。

1.3 应用场景高响应比优先调度算法常常应用于实时操作系统和交互式计算机系统等对响应时间有较高要求的场景。

它能够合理地分配系统资源,提高用户对系统的响应感受,从而提高系统的可用性和用户满意度。

二、时间片轮转(RR)算法2.1 原理介绍时间片轮转(RR)算法是一种公平的进程调度算法,它将系统的CPU时间划分为相等的时间片,并按照轮转的方式分配给就绪队列中的进程。

每个进程在一个时间片内执行一定的时间后,被暂停并放回就绪队列尾部,下一个进程获得执行机会。

这样,所有进程都能够被公平地调度,避免了某个进程长时间占用CPU资源的情况。

高响应比优先调度和时间片轮转rr进程调度算法

高响应比优先调度和时间片轮转rr进程调度算法

高响应比优先调度和时间片轮转rr进程调度算法高响应比优先调度和时间片轮转(RR)进程调度算法引言:在操作系统中,进程调度是一项重要且复杂的任务。

为了提高系统的性能和响应速度,研究人员和工程师开发了许多不同的调度算法。

本文将重点介绍高响应比优先调度(high response ratio priority scheduling)和时间片轮转(round-robin, RR)进程调度算法。

这两种算法都在实际应用中得到了广泛的运用,下面我将对其原理进行详细阐述,并比较它们的优缺点。

一、高响应比优先调度算法高响应比优先调度算法是一种根据进程的等待时间和执行时间来确定优先级的策略。

该算法认为,等待时间越长的进程应该被优先执行,以提高整体系统的响应速度。

具体而言,高响应比=(等待时间+执行时间)/执行时间。

等待时间是指进程在就绪队列中等待调度的时间,而执行时间则是进程实际执行的时间。

高响应比优先调度算法的主要步骤如下:2. 计算响应比:对于每个进程,根据上述公式计算其响应比,并赋予一个优先级。

3. 选择优先级最高的进程:从就绪队列中选择响应比最高的进程,并将其调度到CPU中执行。

4. 更新进程状态:执行完一个时间片后,更新进程的等待时间和执行时间。

5. 重复步骤3和4,直到所有进程都执行完毕。

高响应比优先调度算法的优点在于能够充分利用CPU资源,提高系统的响应速度。

然而,该算法也存在一些缺点。

首先,计算每个进程的响应比需要消耗大量的计算资源。

其次,长时间等待的进程会获得较高的优先级,可能导致一些短进程长时间得不到执行。

因此,在实际应用中需要权衡考虑。

二、时间片轮转调度算法时间片轮转调度算法是一种公平的调度策略,它将CPU的执行时间划分为固定长度的时间片,并将每个进程分配一个时间片来执行。

当一个时间片耗尽后,进程将被重新放入就绪队列中,等待下一次调度。

时间片轮转调度算法的主要步骤如下:2. 选择当前时间片内的进程:从就绪队列中选择一个进程,并将其调度到CPU中执行。

时间片轮转调度算法实验分析报告

时间片轮转调度算法实验分析报告

xx大学操作系统实验报告姓名:学号:班级:实验日期:实验名称:时间片轮转RR进程调度算法实验二时间片轮转RR进程调度算法1.实验目的:通过这次实验,理解时间片轮转RR进程调度算法的运行原理,进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

2.需求分析(1) 输入的形式和输入值的范围;输入:进程个数n 范围:0<n<=100时间片q依次输入(进程名进程到达时间进程服务时间)所有进程平均带权周转时间:(3) 程序所能达到的功能1)进程个数n,输入时间片大小q,每个进程的到达时间T1, … ,T n和服务时间S1, … ,S n。

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

(4) 测试数据,包括正确的输入及其输出结果和含有错误的输入及其输出结果。

正确输入:错误输入:2、概要设计所有抽象数据类型的定义:static int MaxNum=100int ArrivalTime //到达时间int ServiceTime //服务时间int FinishedTime //结束时间int WholeTime //周转时间double WeightWholeTime //带权周转时间double AverageWT //平均周转时间double AverageWWT //平均带权周转时间主程序的流程:●变量初始化●接受用户输入的n,q ,T1…..Tn,S1….Sn;●进行进程调度,计算进程的开始运行时间、结束时间、执行顺序、周转时间、带权周转时间;●计算所有进程的平均周转时间、平均带权周转时间;●按照格式输出调度结果。

各程序模块之间的层次(调用)关系Main函数通过对Input函数进行调用,对函数的成员变量进行赋值,再通过RRAlgorithm函数求出题目要求的各个数据结果,最后通过display函数对结果进行格式输出。

操作系统实验:时间片轮转RR进程调度算法

操作系统实验:时间片轮转RR进程调度算法

实验报告:时间片轮转RR进程调度算法题目:时间片轮转算法的实现班级:软件工程2班姓名:代其全学号:1025111022 完成日期:2012/10/23一.需求分析程序要实现时间片轮转进程调度算法(1)接收用户输入的进程数(n),,各个进程的进程名,到达时间(T1…Tn)和服务时间(S1….Sn),以及时间片大小q。

(2)输出各个进程首次运行的时间(3)输出各个进程的完成时间,周转时间,带权周转时间,所有进程的平均周转时间,以及带权平均周转时间。

(4)测试数据为: 进程数n为5, 各进程的名字,到达时间,服务时间分别为:a 0 4 ; b 1 3; c 2 5; d 3 2; e 4 4。

时间片大小q为1 和5。

二.概要设计抽象数据类型的定义:int ArrivalTime[100];//到达时间int ServiceTime[100];//服务时间int FinishTime[100];//完成时间int WholeTime[100];//周转时间double WeightWholeTime[100];//带权周转时间double AverageWT,AverageWWT;bool Finished[100];//完成标识typedef struct QNode{char name; //进程标识int arrivaltime;//到达时间int servicetime;//服务时间int workedtime; //进程已经运行的时间bool status; //表示进程的状态,1表示已经结束,0表示还未执行struct QNode *next;}QNode, *QueuePtr;typedef struct{QueuePtr front;//队头指针QueuePtr rear;//队尾指针}LinkQueue;主程序的流程:调用Init()函数初始化到达时间,服务时间,时间片等进程信息,调度RR()函数实现轮转调度发,最后调度print()函数输出运算结果三.详细设计1.初始化函数void init(){int cputime;int x,y;char name;cout<<"请输入进程的个数:";cin>>n; //进程个数cout<<endl;for(int i=0;i<n;i++){QNode node;cout<<"请输入第"<<i+1<<"个进程的名字、到达时间和服务时间:";cin>>name>>x>>y;=name;node.arrivaltime=ArrivalTime[i]=x;node.servicetime=ServiceTime[i]=y;node.workedtime=0;node.status=Finished[i]=0;node.next=NULL;array[i]=node;//cout<<"队中增加一个元素"<<endl;cout<<endl;}//各个进程的到达时间和服务时间cout<<"请输入时间片大小:";cin>>cputime;q=cputime;//时间片大小}2.RR()函数void RR(){int temp;QNode e;int count1=0;//按到达时间先后排序进程信息数组for(int i=0;i<n;i++){for(int j=1;j<n-i;j++){if(array[i].arrivaltime>array[i+1].arrivaltime){temp=array[i].arrivaltime;array[i].arrivaltime=array[i+1].arrivaltime;array[i].arrivaltime=temp;}}}//此时,array数组中的元素都是按到达时间从小到大排列的for(i=0;i<n;i++){if(Finished[i]==0){count1++;}}for(int j=0;j<n;j++)if(array[j].arrivaltime==currentTime)EnQueue(queue,array[j]);//将到达时间为当前时间的进程加入到队列中if(count1!=0)//依然有进程未完成{for(int j=0;j<n;j++){if(q>=(*queue.front->next).servicetime)//时间片大于进程服务时间时,进程一次性执行完,进入下一进程{//cout<<"";cout<<"时刻"<<currentTime<<":进程"<<queue.front->next->name<<"开始执行"<<endl;for(int x=0;x<(*queue.front->next).servicetime;x++){currentTime++;for(int y=0;y<n;y++)if(array[y].arrivaltime==currentTime)EnQueue(queue,array[y]);//将到达时间为当前时间的进程加入到队列中}(*queue.front).status=1;//将此进程状态标注为已执行// currentTime=currentTime+(*queue.front->next).servicetime;//更新当前时间cout<<"当前时间为:"<<currentTime<<endl;DeQueue(queue,e);//将此进程出队count++;Finished[count]=1;FinishTime[count]=currentTime;//当前时间为完成时间,返回存放入FinishTime[]数组中}else//时间片小于服务时间时{if((*queue.front->next).workedtime<(*queue.front->next).servicetime)//进程已工作时间小于服务时间时{if((*queue.front->next).workedtime==0)//进程已工作时间为零时{// cout<<"";cout<<"时刻"<<currentTime<<":进程"<<(*queue.front->next).name<<"开始执行"<<endl;// currentTime=currentTime+q;//更新当前时间for(int x=0;x<q;x++){currentTime++;for(int j=0;j<n;j++)if(array[j].arrivaltime==currentTime)EnQueue(queue,array[j]);//将到达时间为当前时间的进程加入到队列中}(*queue.front->next).workedtime+=q;//更新进程已工作时间DeQueue(queue,e);//将该进程出队EnQueue(queue,e);//将该进程入队,加入到了队列的末尾}else//进程工作时间不为零且未达到服务时间时{for(inti=0;i<q&&(*queue.front->next).workedtime!=(*queue.front->next).servicetime;i+ +){currentTime++;//当前时间加一for(int j=0;j<n;j++)if(array[j].arrivaltime==currentTime)EnQueue(queue,array[j]);//将到达时间为当前时间的进程加入到队列中if((*queue.front->next).workedtime==(*queue.front->next).servicetime)//已工作时间达到要求的服务时间{(*queue.front->next).status=1;count++;Finished[count]=1;DeQueue(queue,e);FinishTime[count]=currentTime;//当前时间为完成时间,返回存放入FinishTime[]数组中}}}}}}}}3.输出函数void print(int n){cout<<"完成时间:";for(int i=0;i<n;i++)cout<<FinishTime[i]<<" ";cout<<endl;cout<<"周转时间:"<<" ";for(i=0;i<n;i++){WholeTime[i]=FinishTime[i]-ArrivalTime[i];cout<<WholeTime[i]<<" ";}cout<<endl;cout<<"带权周转时间:";for(i=0;i<n;i++){WeightWholeTime[i]=double(WholeTime[i])/ServiceTime[i];cout<<WeightWholeTime[i]<<" ";}cout<<endl;for(i=1;i<n;i++){WholeTime[0]+=WholeTime[i];}AverageWT=double(WholeTime[0])/n;cout<<"平均周转时间"<<AverageWT<<endl;for(i=1;i<n;i++){WeightWholeTime[0]+=WeightWholeTime[i];}AverageWWT=WeightWholeTime[0]/n;cout<<"带权平均周转时间:"<<AverageWWT<<endl; }4.队列里封装的函数int InitQueue(LinkQueue &q){q.front=q.rear=(QueuePtr)malloc(sizeof(QNode));if(!q.front)return 0;q.front->next=NULL;return 1;}int EnQueue(LinkQueue &q,QNode &e){QueuePtr p=(QueuePtr)malloc(sizeof(QNode));if(!p)return 0;p->name=;p->arrivaltime=e.arrivaltime;p->servicetime=e.servicetime;p->status=e.status;p->workedtime=e.workedtime;p->next=NULL;q.rear->next=p;q.rear=p;return 1;}int DeQueue(LinkQueue &q,QNode &e){if(q.rear==q.front)return 0;QueuePtr p=q.front->next;=p->name;e.arrivaltime=p->arrivaltime;e.servicetime=p->servicetime;e.status=p->status;e.workedtime=p->workedtime;q.front->next=p->next;if(q.rear==p)q.rear=q.front;free(p);return 1;}四.调试分析在时间片大于所有进程的服务时间时,程序正常运行,当时间片小于某些进程的服务时间时,程序不能输出正确的运算结果。

进程调度算法设计(时间片轮转调度算法RR_新旧都有)

进程调度算法设计(时间片轮转调度算法RR_新旧都有)

电子科技大学实验报告学生姓名:满博学号:2823103017 指导教师:罗惠琼一、实验室名称:软件实验室A2412二、实验项目名称:进程调度算法的设计(时间片轮转调度算法RR)说明:同时采用了新旧教材的RR算法(两种算法都在实验报告中给出)三、实验原理:在多道程序系统中,一个作业被提交后必须经过处理机调度后,方能获得处理机执行。

对调度的处理又都可采用不同的调度方式和调度算法。

调度算法是指:根据系统的资源分配策略所规定的资源分配算法。

RR算法:每次调度时,把CPU分配给队首进程,并且令其执行一个时间片,时间片的大小从几个ms到几百ms。

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

这样就可以保证就绪队列中的所有进程在一个给定时间内均能获得一时间片的处理机执行时间。

换言之,系统能在给定的时间内相应所有用户的请求。

四、实验目的:通过对进程调度算法的设计,深入理解进程调度的原理。

五、实验内容:1. 编写RR算法。

进程通过定义一个进程控制块的数据结构(PCB)来表示;●每个进程需要赋予进程ID、进程到达时间、进程需要运行的总时间的属性;●以1为时间片单位;2. 调试无误后运行。

3. 输入需要请求调入的页号。

4. 查看执行结果,根据执行结果判断实验是否成功。

六、实验器材(设备、元器件):1.基本环境要求①宽敞整洁专用实验室②必备的基本实验工具2.最低设备要求①计算机CPU不小于800MHZ;②计算机内存不小于128M;3.软硬件要求①实验平台Visual c++ 6.0七、实验步骤:1.新教材RR代码:#include<stdio.h>#define n 5#define num 5#define max 65535typedef struct pro{int PRO_ID;int arrive_time;int sum_time;int flag;}Pro;void RR(int p){int i,j,c=0;int count=num;int timer=0;Pro seq[n],t;Pro temp_seq[n];for(i=0;i<n;i++){temp_seq[i].PRO_ID=0;temp_seq[i].arrive_time=-1;temp_seq[i].sum_time=0;temp_seq[i].flag=0;}printf("轮转时间片调度算法RR\n");printf("请依次输入%d个进程的进程号、到达时间和执行时间\n",n);printf("成员变量用逗号隔开;进程间用回车隔开\n");for(i=0;i<n;i++){scanf("%d,%d,%d",&seq[i].PRO_ID,&seq[i].arrive_time,&seq[i].sum_time);}//第一个初始化for(i=0;i<n;i++){if(timer==seq[i].arrive_time){temp_seq[0]=seq[i];temp_seq[0].flag=1;c++;timer++;break;}}//开始循环while(count){int flag=0;if(temp_seq[0].flag){printf("%d",temp_seq[0].PRO_ID);temp_seq[0].sum_time--;if(temp_seq[0].sum_time==0&&temp_seq[0].flag!=0){count--;temp_seq[0].flag=0;}for(i=0;i<5;i++){if(timer==seq[i].arrive_time){t=temp_seq[0];temp_seq[c]=seq[i];for(j=0;j<c;j++){temp_seq[j]=temp_seq[j+1];}temp_seq[c]=t;c++;flag=1;}}}if(flag!=1){t=temp_seq[0];for(i=0;i<c;i++){temp_seq[i]=temp_seq[i+1];}temp_seq[c]=t;}timer++;}}void main(){RR(n);}2.旧教材RR代码:#include<stdio.h>#define n 5#define num 5#define max 65535#include<math.h> typedef struct pro{int PRO_ID;int arrive_time;int sum_time;int flag;}Pro;//整数排序int bubble(int temp[]){int i,j,tem=0;for(i=1;i<num;i++){int lastX=1;for(j=0;j<num-i;j++){if(temp[j]>temp[j+1]){tem=temp[j];temp[j]=temp[j+1];temp[j+1]=tem;lastX=0;}}if(lastX==1) break;}return temp[0];}//进程排序void bubble(Pro s[]){int i,j;Pro temp={0};for(i=1;i<num;i++){int lastX=1;for(j=0;j<num-i;j++){if(s[j].arrive_time>s[j+1].arrive_time){temp=s[j];s[j]=s[j+1];s[j+1]=temp;lastX=0;}}if(lastX==1) break;}}void PCB(int p){if(n>0){int i;Pro seq[n];printf("旧教材轮转时间片调度算法RR\n");printf("请依次输入%d个进程的进程号、到达时间和执行时间\n",n);printf("成员变量用逗号隔开;进程间用回车隔开\n");for(i=0;i<n;i++){scanf("%d,%d,%d",&seq[i].PRO_ID,&seq[i].arrive_time,&seq[i].sum_time);}bubble(seq);/* for(i=0;i<num;i++){printf("%d,%d,%d\t",seq[i].PRO_ID,seq[i].arrive_time,seq[i].sum_time);}*/for(i=0;i<num;i++){if(seq[i].sum_time!=0){printf("%d",seq[i].PRO_ID);seq[i].sum_time--;seq[i].flag=1;}if((i+1)==num) i=-1;}printf("\n\b");}}void main(){PCB(n);}旧教材RR结果截图如下:旧教材实例新教材RR结果截图如下:新教材实例八、实验数据及结果分析:新旧RR算法的结果都与新旧教材的结果相同,RR算法功能已实现。

实验一 时间片轮转进程调度算法

实验一 时间片轮转进程调度算法

实验一时间片轮转进程调度算法时间片轮转(Round Robin)是一种常见的进程调度算法,其核心思想是每个进程被分配一个时间片,当时间片用完时,CPU会切换到下一个进程。

这种算法简单高效,能够保证每个进程都能获得公平的CPU时间。

在时间片轮转算法中,每个进程被分配一个相同大小的时间片,通常为几十毫秒到几百毫秒不等。

当一个进程占用完了其时间片,CPU会将其放入就绪队列的末尾,并将CPU分配给队列中的下一个进程。

这种方式可以确保每个进程都有机会运行,并且不会出现某个进程长时间占用CPU,导致其他进程饥饿的情况。

时间片轮转算法的优点之一是简单易实现,只需要设置一个固定的时间片大小和一个就绪队列即可。

另外,由于每个进程都有相同的时间片,因此可以较好地保证公平性,避免某个进程长时间占用CPU而导致其他进程无法运行的情况。

然而,时间片轮转算法也存在一些缺点。

首先,如果时间片设置过小,会导致频繁的进程切换,增加了系统的开销。

而如果时间片设置过大,可能会出现某些进程长时间占用CPU的情况,降低了系统的响应速度。

因此,选择合适的时间片大小对系统的性能至关重要。

另外,时间片轮转算法对I/O密集型的进程并不友好。

由于I/O操作需要等待外部设备的响应,进程可能会在I/O操作期间主动放弃CPU,这样会导致进程在等待I/O时浪费了部分时间片。

为了解决这个问题,可以考虑将I/O操作的等待时间纳入时间片,或者采用其他更适合I/O密集型进程的调度算法。

总的来说,时间片轮转算法是一种简单高效的进程调度算法,适用于大多数情况下。

在实际应用中,需要根据系统的特点和需求选择合适的时间片大小,以提高系统的性能和响应速度。

同时,针对不同类型的进程可以结合其他调度算法,以达到更好的效果。

实验二 时间片轮转RR进程调度算法

实验二  时间片轮转RR进程调度算法

实验二时间片轮转RR进程调度算法1、需求分析(1) 输入的形式和输入值的范围首先输入进程个数,然后再输入时间片的大小,然后按照到达时间的顺序输入每个进程的名字,然后输入进程到达的时间和服务时间,输入完成,程序显示算法的结果。

(2) 输出的形式程序的输出根据用户输入的时间片的大小到达时间以及服务时间,通过相应的计算输出其各自的完成时间,周转时间,带全周转时间以及平均值,程序输出这些结果。

3) 程序所能达到的功能1)输入进程个数n,时间片的大小t以及每个进程的名字和每个进程的到达时间T1, … ,T n和服务时间S1, … ,S n。

2)时间片轮转法RR调度进程运行,计算每个进程的周转时间和带权周转时间,并且计算所有进程的平均周转时间和带权平均周转时间。

3)输出:输出计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。

(4) 测试数据,包括正确的输入及其输出结果和含有错误的输入及其输出结果正确输入的结果错误输入的结果2、概要设计抽象数据类型的定义:int ArrivalTime[100];int ServiceTime[100];int PServiceTime[100];int FinishTime[100];int WholeTime[100];double WeightWholeTime[100];double AverageWT,AverageWWT;bool Finished[100];主程序的流程以及各程序模块之间的层次(调用)关系:3、详细设计该算法采用队列的方法实现。

先将第一个到达的进程入队,在规定的时间内将其运行,也有可能其服务时间小于实际时间片。

此时判断其他的程序有没有到达,到达就将其入队,没有到达则等待,然后判断此时在队头的进程是否完成执行,如果已经完成执行吗,则将其出对,若还没有完成,则将其调配到队尾,现在打头的进程依旧执行此方法判断,知道所有的进程都出队。

实验三

实验三

操作系统实验实验三进程调度学号姓名班级华侨大学电子工程系实验目的1、理解有关进程控制块、进程队列的概念。

2、掌握进程优先权调度算法和时间片轮转调度算法的处理逻辑。

实验内容与基本要求1、设计进程控制块PCB的结构,分别适用于优先权调度算法和时间片轮转调度算法。

2、建立进程就绪队列。

3、编制两种进程调度算法:优先权调度算法和时间片轮转调度算法。

实验报告内容1、优先权调度算法和时间片轮转调度算法原理。

2、程序流程图。

3、程序及注释。

4、运行结果以及结论。

1.按优先数调度算法原理优先权调度算法可分为非抢占式优先权算法和抢占式优先权调度算法两种方式。

1.非抢占式优先权算法(本实验用这种优先权算法)在这种方式下,系统一旦把处理机分配给就绪队列中优先权最高的进程后,该进程便一直执行下去,直至完成; 或因发生某事件使该进程放弃处理机时,系统方可再将处理机重新分配给另一优先权最高的进程.这种调度算法主要用于批处理系统中;也可用于某些对实时性要求不严的实时系统中.2.抢占式优先权调度算法系统同样把处理机分配给优先权最高的进程,使之执行.但在其执行期间,只要又出现了另一个其优先权更高的进程,进程调度程序就立即停止当前进程(原优先权最高的进程)的执行,重新将处理机分配给新到的优先权最高的进程.这种抢占式的优先权调度算法,能更好地满足紧迫作业的要求,常用于要求比较严格的实时系统中, 以及对性能要求较高的批处理和分时系统中.2.时间片轮转法原理在时间片轮转法中,系统将所有的就绪进程按先来先服务的原则,排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片.时间片的大小从几ms到几百ms.当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片.这样就可以保证就绪队列中的所有进程,在一给定的时间内,均能获得一时间片的处理机执行时间.(1) 假定系统有五个进程,每一个进程用一个进程控制块PCB来代表。

深入理解操作系统中的进程调度算法

深入理解操作系统中的进程调度算法

深入理解操作系统中的进程调度算法简介操作系统是计算机硬件和应用程序之间的桥梁,负责管理和协调计算机资源。

其中最重要的功能是进程调度,它决定了哪些进程将在何时运行以及它们将占据多少资源。

在这篇文章中,我将深入探讨操作系统中的进程调度算法。

什么是进程调度在操作系统中,进程是可执行程序的一部分,它包含指令,数据和其他系统资源。

当我们启动一个程序时,操作系统会创建一个进程,然后将CPU的执行权交给该进程。

实际上,在任何给定时间都可能存在多个进程,它们都正在等待被执行。

进程调度就是决定哪个进程将获得CPU的执行权,以及在何时获得。

进程调度算法操作系统中最常用的进程调度算法是时间片轮转和优先级调度。

时间片轮转算法时间片轮转算法是一种最基本的调度算法。

它将CPU的执行时间分割成一些均等的时间片,每个进程均得到一个时间片,执行完后排到队伍的末尾等待下一个时间片。

这种算法是个公平的方式,以确保每个进程都有足够的时间去完成执行任务。

然而,时间片轮转算法容易引起"饥饿"现象。

如果有许多高优先级的进程,哪怕时间片切得再小,低优先级的进程也无法得到执行。

因此,在实际应用中需要考虑其他的因素,例如进程优先级,来解决这个问题。

优先级调度算法优先级调度算法将CPU的执行权授予优先级最高的进程。

如果一个新进程进入系统,它的优先级就很高,所以会立即得到CPU的执行权。

如果高优先级进程的数量太多,就会被低优先级进程推迟执行。

因此,如果一个进程一直处于低优先级状态,那么它的执行可能永远不会到来。

公平性是优先级调度算法的一个问题。

如果高优先级进程一直在运行,而低优先级进程一直处于等待状态,会导致低优先级进程的永久饥饿。

多级反馈队列调度算法多级反馈队列调度算法是一种混合调度算法,它结合了时间片轮换,优先级以及其他因素。

多级反馈队列调度算法将进程分为不同级别的队列,具有相同优先级的一批进程被放置在同一个队列中。

每个队列都有一个预定好的时间量,过了这个时间量后,进程被移到更高优先级的队列中。

教你理解时间片轮转调度算法

教你理解时间片轮转调度算法

2. 时间片轮转法(RR )算法描述:用于分时系统中的进程调度。

每次调度时,总是选择就绪队列的队首进程,让其在CPU 上运行一个系统预先设置好的时间片。

一个时间片内没有完成运行的进程,返回到绪队列末尾重新排队,等待下一次调度。

【例2】进程A 、B 、C 、D 需要运行的时间分别为20ms 、10 ms 、15 ms 、5 ms ,均在0时刻到达。

到达的先后次序为A →B →C →D 。

如果时间片分别为1 ms 和5ms ,计算各个进程的带权周转时间和平均带权周转时间。

分析 在掌握了时间片轮转法概念的基础上,我们可以用一个执行时间图来形象地表示作进程的执行情况,帮助我们理解此题。

具体如下:根据执行时间图就可以计算各个进程的带权周转时间和平均带权周转时间了。

这里要注意的是,要记住带权周转时间和平均带权周转时间的算术公式:带权周转时间W ,即:W=RT其中T 为周转时间,R 为实际运行时间。

平均带权周转时间为:n RT n W W n i i in i i 1111⨯⎪⎪⎭⎫ ⎝⎛=⨯⎪⎪⎭⎫ ⎝⎛=∑∑==解:采用时间片轮转法进行调度,算法的性能指标如下:到达时间 进程 名到达时间 运行时间 开始时间 完成时间 周转时间带权周转时间 0 5 10 15 20 25 30 35 40 45 50 进程 D C B A D C B A 时间片=1时间片=5时间片=1 A 0 20 0 50 50 2.5B 0 10 1 34 34 3.4C 0 15 2 45 45 3.0D 0 5 3 20 20 4.0平均周转时间T=37.25 平均带权周转时间W=3.225时间片=5 A 0 20 0 50 50 2.5B 0 10 5 30 30 3.0C 0 15 10 45 45 3.0D 0 5 15 20 20 4.0平均周转时间T=36.25 平均带权周转时间W=3.125感兴趣的同学还可以根据时间片从1~10的变化,多计算几次,并分析每次计算得到的平均周转时间,做一条平均周转时间随时间片变化的曲线,来体会时间片的变化对平均周转时间的影响,并分析原因。

时间片轮转RR进程调度算法

时间片轮转RR进程调度算法

时间片轮转RR进程调度算法时间片轮转(Round-Robin,简称RR)是一种常见的进程调度算法,它被广泛应用于操作系统中。

在RR算法中,每个进程被分配一个时间片,当时间片用完后,操作系统会将CPU的控制权交给下一个就绪队列中的进程。

这种算法的主要目标是公平地分配CPU时间,并且保证所有进程能够得到一定的执行时间,避免一些进程长时间占用CPU。

1.创建就绪队列:当进程处于就绪状态时,将其加入就绪队列中,按照先来先服务原则进行排队。

2.分配时间片:给每个进程分配一个固定长度的时间片,通常为10-100毫秒,具体取决于系统的要求。

3.执行进程:选择就绪队列中的第一个进程执行,并将其从队列中取出。

4.时间片到期:当进程执行的时间超过了分配给它的时间片长度时,需要进行下一步操作。

5.时间片用完:将当前正在执行的进程重新加入到就绪队列中,并且将下一个进程从队列中取出继续执行。

6.进程完成:当进程执行完毕后,将其标记为已完成,并从就绪队列中移除。

7.循环执行:循环执行以上步骤,直到所有进程都完成执行。

然而,时间片轮转算法也存在一些缺点:1.时间片长度选择:时间片过短会导致频繁的上下文切换,增加了系统开销;时间片过长则可能导致一些进程长时间占用CPU。

2.需要等待时间:如果一些进程的执行时间过长,其他进程可能需要等待较长时间才能获得CPU的控制权,影响了系统的响应速度。

3.无法适应突发性任务:对于一些突发性任务,时间片轮转算法可能无法满足其紧急性,因为它只能按照排队顺序执行进程。

为了解决这些问题,可以采取一些改进措施,例如:1.动态调整时间片长度:根据系统的运行情况动态调整时间片的长度,避免了时间片过短或过长的问题。

2.使用优先级队列:根据进程的优先级将其加入不同的队列中,从而优先执行高优先级的进程。

3.引入抢占机制:在一些特定情况下,例如优先级较高的进程到达或一些进程的执行时间超过一定阈值,系统可以主动剥夺正在执行的进程的CPU控制权,以保证紧急任务的执行。

实验二时间片轮转RR进程调度算法

实验二时间片轮转RR进程调度算法

实验二时间片轮转RR进程调度算法一: 需求分析(1)程序的设计的任务和目的:设计程序模拟进程的时间片轮转RR调度过程。

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

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

(2)通过这次实验, 加深对进程概念的理解, 进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

(3)输入的形式和输入值的范围为避免测试时频繁输入数据, 将测试数据放在txt文件中采用读文件方法读取数据。

在同目录下的txt文件中输入数据, 第一行为进程到达时间, 中间用空格隔开, 第二行为进程服务时间, 不同进程的服务时间之间用空格隔开。

(2) 输出的形式输出每个时刻的进程运行状态, 并且输出计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。

(详见运行截图)(3) 程序所能达到的功能;详见运行结果截图2、概要设计使用链表创建队列, 用链表方法实现时间片轮转调度。

主要有主函数, 时间片轮转调度函数void RR(int*ArrivalTime,int*ServiceTime,int n,int q,LinkQueue &Q)和输出函数voidprint(int n,int array[]), void print(int n,double array[]);三: 详细设计时间片轮转算法流程图:程序主要设计思想:(1)创建进程, 使用链表的方法, 链表中的每个结点相当于一个进程。

(2)读入文件中进程数据(进程的到达时间和服务时间)。

(3)创建一个进程单链表, 作为进程队列。

(4)请用户输入时间片大小。

(5)创建执行队列。

(6)定义时间轴, 初始化时间轴和执行队列。

时间片轮转调度算法

时间片轮转调度算法

时间⽚轮转调度算法实验⼆时间⽚轮转调度算法实验内容:模拟实现时间⽚轮转调度算法,具体如下:设置进程体:进程名,进程的到达时间,服务时间,,进程状态(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)实验结果:。

实验二 RR

实验二 RR

实验二时间片轮转RR进程调度算法实验目的:通过这次实验,加深对进程概念的理解,进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

实验内容:设计程序模拟进程的时间片轮转RR调度过程。

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

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

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

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

源程序:#include "stdafx.h"#include <iostream>#include <iomanip>using namespace std;typedef struct pcb{char pname;int ServiceTime;int ArrivalTime;int hasFinishTime;int FinishTime;int WholeTime;double WeightWholeTime;struct pcb *next;}PCB;PCB *head;PCB *head1;PCB *insert;int systime;void Input(int n){PCB *input;insert = head;cout<<"依次输入:进程名到达时间服务时间"<<endl;for (int i = 0; i <n; i++){bool inserted = false;input = new PCB;input ->next = NULL;cin>>input->pname>>input->ArrivalTime>>input->ServiceTime;input->hasFinishTime=0;for (insert = head; insert ->next != NULL; insert = insert ->next){if (input->ArrivalTime < insert ->next ->ArrivalTime){input ->next = insert ->next;insert ->next = input;inserted = true;break;}}if (!inserted){insert ->next = input;}}}void RR(int n,int q){PCB *buff,*p,*w;int x,a;systime = head ->next ->ArrivalTime;w=head1;a=q;while(head->next!=NULL){q=a;p=head->next;x=p->ServiceTime - p->hasFinishTime;if(x<q) q=x;cout<<"时刻"<<systime<<":进程"<<p->pname<<"开始运行"<<endl;p->hasFinishTime=p->hasFinishTime+q;systime=systime+q;if(p->hasFinishTime==p->ServiceTime){p->FinishTime=systime;p->WholeTime=p->FinishTime-p->ArrivalTime;p->WeightWholeTime=p->WholeTime*1.0/p->ServiceTime;head->next=p->next;w->next=p;p->next=NULL;w=w->next;p=head->next;}else{for(;p->next!=NULL&&p->next->ArrivalTime<=systime;p=p->next){} buff=head->next;head->next=buff->next;buff->next=p->next;p->next=buff;}}}void Output(int n){PCB *buff;double a,b;a=0;b=0;for( buff = head1 ->next;buff!= NULL;buff = buff->next){cout<<"进程名:"<<buff->pname<<" 完成时间:"<<buff->FinishTime<<" 周转时间:"<<buff->WholeTime<<" 带权周转时间:"<<buff->WeightWholeTime<<endl;a=buff->WholeTime+a;b=buff->WeightWholeTime+b;}cout<<"平均周转时间:";cout<<a*1.0/n<<endl;cout<<"平均带权周转时间:";cout<<b*1.0/n<<endl;}int main(){head = new PCB;head ->next = NULL;head1 = new PCB;head1->next = NULL;int n,q;cout<<"输入进程个数:";cin>>n;Input(n);cout<<"输入时间片:";cin>>q;RR(n,q);Output(n);system("pause");return 0;}实例运行结果截图:发现的问题:起初输出时间出错,输出成完成的时刻. 解决方法:仔细再次查看,现在已排错了。

时间片轮转RR进程调度算法实验报告

时间片轮转RR进程调度算法实验报告

时间片轮转RR进程调度算法学生姓名:学生学号:专业班级:指导老师:2013年6月20日1、实验目的通过这次实验,加深对进程概念的理解,进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

2、问题描述设计程序模拟进程的时间片轮转RR调度过程。

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

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

3、需求分析1)进程个数n;每个进程的到达时间T1, … ,T n和服务时间S1, … ,S n;输入时间片大小q。

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

4、概要设计(1)程序中进程调度时间变量描述如下:2)程序流程:变量初始化;接收用户输入n,T1, … ,T n,S1, … ,S n;时间片大小q;按照时间片轮转RR算法进行进程调度,计算进程的完成时间、周转时间和带权周转时间;计算所有进程的平均周转时间和平均带权周转时间;按格式输出调度结果。

5、详细设计构造一个队列int InitQueue(LinkQueue &Q)//构造一个空队列Q{Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));if(!Q.front)exit(OVERFLOW);Q.front->next=NULL;return OK;}时间片轮转RR进程调度算法void RR(int*ArrivalTime,int*ServiceTime,int n,int q,LinkQueue &Q){cout<<"--------------------------------------------------------------"<<endl;cout<<" 时间片轮转RR进程调度算法"<<endl;cout<<"--------------------------------------------------------------"<<endl;int countTime=0;int e;int STime[MaxNum];int PT[MaxNum];for(int i=0;i<n;i++){STime[i]=ServiceTime[i];PT[i]=0;}InitQueue(Q);EnQueue(Q,0);PT[0]=1;int time=0;while(QueueEmpty(Q)==false){e=DeQueue(Q,e);if(STime[e]>q){STime[e]=STime[e]-q;countTime+=q;}else{countTime+=STime[e];STime[e]=0;FinishedTime[e]=countTime;}while(time<countTime){if(STime>0){cout<<"时刻"<<setw(2)<<time<<":进程"<<e<<"正在运行"<<endl;}time++;}for(i=1;i<n;i++){if(STime!=0&&i!=e&&ArrivalTime[i]<countTime&&PT[i]==0||STime!=0&&i!=e&&ArrivalTime[i]==cou ntTime){EnQueue(Q,i);PT[i]=1;}}if(STime[e]>0){EnQueue(Q,e);}}for(i=0;i<n;i++){WholeTime[i]=FinishedTime[i]-ArrivalTime[i];WeightWholeTime[i]=(double)(WholeTime[i]*1.000/ServiceTime[i]);Average_WT+=WholeTime[i];Average_WWT+=WeightWholeTime[i];}Average_WT/=n;Average_WWT/=n;cout<<"完成:"<<" ";for(i=0;i<n;i++)cout<<setw(6)<<FinishedTime[i]<<" ";cout<<endl;cout<<"周转:"<<" ";for(i=0;i<n;i++)cout<<setw(6)<<WholeTime[i]<<" ";cout<<endl;cout<<"带权:"<<" ";for(i=0;i<n;i++)cout<<setw(6)<<setiosflags(ios::fixed)<<setprecision(2)<<WeightWholeTime[i]<<" ";cout<<endl;cout<<"平均周转时间为:"<<Average_WT<<endl;cout<<"平均带权周转时间为:"<<Average_WWT<<endl;DestroyQueue(Q);}实现程序模块的具体调用:int InitQueue(LinkQueue &Q)//构造一个空队列Q用于存放所有就绪进程{ }void RR( )}时间片轮转RR进程调度算法}void main() //主函数{输入进程个数输入每个进程的到达时间输入每个进程的服务时间输入时间片qvoid RR( )}6、调试分析1、输出的时候没有进行各个状态的输出,所以在代码书写的时候使得这一块很难添加进去,最后经过在合适的输出链表的状态显示出了各个时刻进程的状态。

时间片轮转调度算法实现

时间片轮转调度算法实现

时间片轮转调度算法实现
时间片轮转调度算法(Round Robin Scheduling Algorithm)是一种常用的进程调度算法,其特点是将系统中的所有进程按照一定的时间片大小进行轮流调度执行,从而保证每个进程都能够获得一定的CPU时间,同时避免了某个进程长时间占用CPU的情况。

时间片轮转调度算法的基本原理是将所有就绪进程按照先后顺序排成一个队列,然后按照固定的时间片大小为每个进程分配一定的CPU时间,并在时间片用完后将进程从队列头部移到队列尾部,等待下一次调度。

这样,每个进程都能够得到一定的CPU时间,同时也保证了系统的公平性和响应性。

在实际运用中,时间片大小的选择对于系统的性能和响应速度有着重要的影响。

如果时间片过短,会导致进程过于频繁地进行上下文切换,从而降低系统的效率;如果时间片过长,会导致某些进程长时间占用CPU资源,影响其他进程的运行。

因此,在进行时间片大小的选择时,需要考虑系统的硬件配置、进程的性质、调度算法的实现等多方面因素。

通常情况下,时间片大小的选择应该根据实际情况进行调整,以保证系统的性能和响应速度。

除了时间片大小的选择之外,时间片轮转调度算法还有其它一些优化技巧,例如优先级调度、多级反馈队列调度等。

这些技巧能够进
一步提高系统的性能和响应速度,同时也能够更好地适应不同性质的进程。

时间片轮转调度算法是一种简单而有效的进程调度算法,在实际运用中有着广泛的应用。

通过合理地选择时间片大小、实现优化技巧等手段,能够更好地提高系统的性能和响应速度,为用户提供更加优质的服务。

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

《操作系统》实验二内实验报告作者:mo唏【实验题目】:时间片轮转RR进程调度算法【实验目的】通过这次实验,加深对进程概念的理解,进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

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

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

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

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

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

[ 源程序]程序结构:Process.javapackage com.RoundRobin;/*** 功能:* 定义进程类* method:* 进程按到达时间排序* 进程RR 时间片轮转法* @author Rain**/class Process {private String name; //进程名private int arriveTime; //到达时间private int serviceTime; //服务时间private int finishTime; //完成时间private int roundTime; //周转时间private double weightroundTime; //带权周转时间private double aveweightroundTime; // 平均带权周转时间private double averoundTime; //平均带权周转时间private int temp;private boolean isAction;public Process() {name = "";arriveTime = 0;serviceTime = 0;finishTime = 0;roundTime = 0;weightroundTime = 0;averoundTime = 0;aveweightroundTime = 0;temp = 0;isAction = false;}public void setName(String name) { = name;}public void setArriveTime(int arriveTime) { this.arriveTime = arriveTime;}public void setServiceTime(int serviceTime) { this.serviceTime = serviceTime;this.temp = serviceTime;}public void sort(Process[] a) { //对进程进行排序for (int j = 1; j < a.length; j++) {Process b = a[j];int temp = a[j].arriveTime;int jj = j - 1;while (jj >= 0) {if (temp < a[jj].arriveTime) {a[jj + 1] = a[jj];jj--;} elsebreak;}a[jj + 1] = b;}//for}//sort/**** @param a* @param q* 时间片轮转算法*/public void RR(Process[] a, int q) {Queue aQueue = new Queue();aQueue.enqueue(0);int j;int i = 1;int time = a[0].finishTime;int count = 0;for (int m = 0; m < a.length; m++)count += a[m].serviceTime;int temp = -1;while (!aQueue.isEmpty()) {a[aQueue.front()].temp = a[aQueue.front()].temp - q;if (a[aQueue.front()].temp >= 0) {System.out.print("第"+time);time = q + time;a[aQueue.front()].finishTime = time;System.out.println("到" + a[aQueue.front()].finishTime + "时间刻"+"进程"+ a[aQueue.front()].name+"在运行");}if (a[aQueue.front()].temp < 0) {System.out.print("第"+time);time = a[aQueue.front()].temp + q + time;a[aQueue.front()].finishTime = time;System.out.println("到" + a[aQueue.front()].finishTime + "时间刻" + "进程"+ a[aQueue.front()].name + "在运行");a[aQueue.front()].temp = 0;}for (j = i; j < a.length; j++) {if (a[j].arriveTime <= time) {a[j].isAction = true;aQueue.enqueue(j);i++;}else continue;}if (a[aQueue.front()].temp== 0){a[aQueue.front()].finishTime = time;if(aQueue.isEmpty() != true){aQueue.dequeue();}}else{temp=aQueue.front();aQueue.dequeue();aQueue.enqueue(temp);}}for(int jj=0; jj<a.length; jj++){a[jj].roundTime = a[jj].finishTime - a[jj].arriveTime;a[jj].weightroundTime = (double)a[jj].roundTime / a[jj].serviceTime;a[0].aveweightroundTime += a[jj].weightroundTime;a[0].averoundTime += a[jj].roundTime;}a[0].aveweightroundTime = a[0].aveweightroundTime / a.length;a[0].averoundTime = a[0].averoundTime / a.length;}//RR/*** 打印结果* @param a** */public void print(Process[] a) {System.out.println("进程名" + " " + "到达时间" + " " + "服务时间" + " " + "完成时间"+ " " + "周转时间" + " " + "带权周转时间");//DecimalFormat df = new DecimalFormat("#.00");for (int ii = 0; ii < a.length; ii++) {System.out.println(" " + a[ii].name + " " + a[ii].arriveTime+ " " + a[ii].serviceTime + " "+ a[ii].finishTime + " " + a[ii].roundTime+ " " + Math.floor( a[ii].weightroundTime*100+0.5 )/100 );}System.out.println("RR算法的平均周转时间为:" + Math.floor( a[0].averoundTime*100+0.5 )/100 );System.out.println("RR算法的平均带权周转时间:"+ Math.floor( a[0].aveweightroundTime*100 + 0.5 )/100 );}//print}Queue.javapackage com.RoundRobin;import java.util.NoSuchElementException;/*** 自定义队列来存储进程* 通过数组来实现队列**/class Queue {// 字段public static int[] data;// 队列的元素个数protected int size;// 队列头protected int head;// 队列尾public static int tail;// 无参数构造函数public Queue() {final int INITIAL_LENGTH = 100;data = new int[INITIAL_LENGTH];size = 0;head = 0;tail = -1;}// 队列元素个数方法public int size() {return size;}public boolean isEmpty() {return size == 0;}// 得到队列头元素public int front() {if (size == 0)throw new NoSuchElementException();else return data[head];}// 进入队列enqueue()方法public void enqueue(int obj) {// 此时队列已经满if (size == data.length) {int[] oldData = data;data = new int[data.length * 2];if(head == 0)System.arraycopy(oldData, head, data, 0, oldData.length - head);if (head > 0)System.arraycopy(oldData, 0, data, head + 1, tail + 1);head = 0;tail = oldData.length - 1;}tail = (tail + 1) % data.length;size++;data[tail] = obj;}// 队列的元素出队public int dequeue() {if (size == 0)throw new NoSuchElementException();int ele = data[head];// 循环队列//head++;head = (head + 1) % data.length;size--;return ele;}}RR.javapackage com.RoundRobin;import java.io.*;import java.util.Scanner;import com.RoundRobin.Process ;public class RR {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubSystem.out.println("\n--------模拟操作系统进程调度---- 时间片轮转法-----");int i = 0;String[] S1 = new String[20];try {FileReader aFileReader = new FileReader("data.txt");BufferedReader in = new BufferedReader(aFileReader);String s = null;while ((s = in.readLine()) != null) {S1[i] = s;i++;}aFileReader.close();in.close();} catch (IOException ioe) {System.out.println( ioe.getMessage() );}int choice=-1;while( true ){System.out.println(" 1.开始或继续:");System.out.println(" 0.退出。

相关文档
最新文档