时间片轮转调度算法实验报告
时间片算法实验报告
时间片算法实验报告时间片调度算法是一种基于轮询的调度算法,在实验中它被应用于多道程序运行环境中,实现了多个程序之间的轮流执行。
本实验旨在通过实现一个基于时间片调度算法的简单操作系统,以及对其进行性能评估来深入理解该调度算法的工作原理和优缺点。
1. 实验所用材料与方法本实验使用C语言编程实现一个具有基本功能的操作系统。
在该系统中,定义了一个PCB(Process Control Block,进程控制块)结构体,用于保存进程的相关信息,如进程ID、优先级、状态等。
同时,系统中维护一个进程队列,用于存储所有申请CPU时间片的进程。
在时间片调度算法中,系统将时间划分为固定的时间片,当一个进程得到CPU 的时间片后,执行一段指定的CPU时间,然后被中断,以便让其他进程获得执行的机会。
在本实验中,假设每个时间片的长度为100ms。
2. 实验过程与结果在实验中,首先实现了一个简单的时间片调度算法的操作系统,并使用该操作系统执行了一系列的测试任务,利用日志记录了每个任务的执行时间和完成情况。
然后,对比了不同任务数量和优先级情况下的系统性能,并分析了结果。
通过实验结果可以看出,当任务数量较少时,时间片调度算法能够保证每个任务能够按照预期的时间片轮流执行,且每个任务完成时间较为均衡。
然而,当任务数量增多时,由于时间片的限制,每个任务能够获得的执行时间减少,导致任务完成时间延长,系统的响应时间也相应增加。
此外,实验还对比了不同优先级的任务在系统中的执行情况。
当任务的优先级较高时,系统会优先执行这些任务,从而保证任务的及时响应。
然而,如果某些优先级较低的任务长时间得不到执行,可能会导致任务的响应速度变慢,甚至影响整个系统的正常运行。
3. 实验总结与思考时间片调度算法是一种简单且公平的调度算法,它能够有效地提高多任务环境中任务的响应速度。
然而,该算法也存在一些不足之处。
首先,由于每个任务只能获得固定的执行时间片,当任务数量增多时,每个任务可获得的执行时间减少,从而导致任务的完成时间延长。
时间片轮转调度算法实验
时间片轮转调度算法实验时间片轮转调度算法是一种广泛应用于计算机操作系统中的调度算法。
本文将介绍时间片轮转调度算法的基本原理、特点以及实验过程。
一、时间片轮转调度算法的基本原理时间片轮转调度算法是一种基于时间片的调度算法,它将CPU时间分配给多个进程,每个进程都被赋予一个时间片,当时间片用完后,该进程将被挂起,CPU时间将被分配给下一个进程。
被挂起的进程将被放入一个就绪队列中,等待下一轮时间片到来。
二、时间片轮转调度算法的特点1.公平性:时间片轮转调度算法可以保证每个进程都能够得到一定的CPU时间,从而保证了公平性。
2.响应时间快:时间片轮转调度算法可以保证进程的响应时间快,因为每个进程都会被分配一定的CPU时间。
3.适用性广:时间片轮转调度算法适用于多种场景,包括多用户、多任务、实时任务等。
4.实现简单:时间片轮转调度算法的实现比较简单,可以通过一个就绪队列和一个定时器来实现。
三、时间片轮转调度算法的实验过程1.实验环境:本次实验使用了Linux操作系统,编程语言为C++。
2.实验步骤:(1)创建进程:首先需要创建多个进程,并将它们放入就绪队列中。
(2)分配时间片:为了模拟时间片轮转调度算法,需要为每个进程分配一个时间片。
(3)执行进程:按照就绪队列中的顺序,依次执行每个进程,并在执行完一个时间片后,将进程放回就绪队列中。
(4)更新进程状态:根据进程的执行情况,更新进程的状态,包括运行中、就绪、阻塞等。
(5)输出结果:最后,输出每个进程的执行结果,包括进程的状态、执行时间等。
3.实验结果:经过实验,我们发现时间片轮转调度算法可以保证每个进程都能够得到一定的CPU时间,并且响应时间较快。
同时,我们也发现时间片的大小会对进程的执行时间和响应时间产生影响。
如果时间片过小,会导致进程频繁切换,从而降低CPU的利用率;如果时间片过大,会导致进程响应时间过长,影响用户体验。
四、总结时间片轮转调度算法是一种广泛应用于计算机操作系统中的调度算法,具有公平性、响应时间快、适用性广、实现简单等特点。
操作系统实验二报告-时间片轮转进程调度算法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算法进行进程调度, 计算进程的完成时间、周转时间和带权周转时间;➢计算所有进程的平均周转时间和平均带权周转时间;➢按格式输出调度结果。
实验二时间片轮转算法实验报告
实验二时间片轮转算法实验报告一、实验目的本次实验的主要目的是了解时间片轮转算法的工作原理,学习如何使用时间片轮转算法进行进程调度,并了解时间片大小对进程调度的影响。
二、实验原理时间片轮转算法是一种公平的进程调度算法,它采用循环队列的形式,将所有需要运行的进程按照到达时间排序,并将它们按照轮转的方式依次执行,每个进程在一个时间片内执行一定的时间(时间片大小),然后被暂停并放在队列的末尾等待下一次调度。
当一个进程的时间片用完后,它会被暂停并放在队列的最后,而在这个时间片内没有执行完的进程会被暂停并放到队列的开头,以便继续下一轮的运行。
这样一直循环下去,直到所有进程都运行完毕。
三、实验步骤1.设定进程数量和时间片大小。
2.定义进程结构体,包括进程ID、到达时间、服务时间、剩余时间等信息。
3.初始化所有进程,并按照到达时间排序。
4.创建一个循环队列,并将所有已到达的进程入队。
5.按照时间片大小循环执行以下步骤:a.从队列中取出一个进程,执行一次时间片大小的时间。
b.更新队列中所有进程的剩余时间。
c.如果剩余时间大于0,将进程放入队尾。
d.如果剩余时间等于0,表示进程执行完毕,将其从队列中移除。
e.输出每个时间片的调度情况。
6.统计平均等待时间和平均周转时间,并输出结果。
四、实验结果本次实验我们设置了4个进程,并且时间片大小为3、以下是每个时间片的调度情况:时间片1:进程1执行,剩余时间为2时间片2:进程2执行,剩余时间为4时间片3:进程3执行,剩余时间为5时间片4:进程1执行,剩余时间为1时间片5:进程2执行,剩余时间为3时间片6:进程3执行,剩余时间为4时间片7:进程4执行,剩余时间为2时间片8:进程1执行,剩余时间为0,进程1执行完毕时间片9:进程2执行,剩余时间为2时间片10:进程3执行,剩余时间为3时间片11:进程4执行,剩余时间为1时间片12:进程2执行,剩余时间为1时间片13:进程3执行,剩余时间为2时间片14:进程4执行,剩余时间为0,进程4执行完毕时间片15:进程2执行,剩余时间为0,进程2执行完毕时间片16:进程3执行,剩余时间为1时间片17:进程3执行,剩余时间为0根据以上调度情况,我们可以计算出平均等待时间和平均周转时间。
时间片轮转调度算法实验
时间片轮转调度算法实验时间片轮转调度算法是一种基于时间片轮转的进程调度算法,它按照轮转的方式,将每个进程分配一个时间片,如果该进程在时间片结束前未完成其任务,则该进程将被挂起,然后下一个进程继续执行。
下面将从实验过程、结果分析和算法优缺点三个方面回答该问题。
实验过程:本次实验使用C语言编写程序,模拟了一个简单的时间片轮转调度算法。
实验环境为Windows 10操作系统,使用了Dev-C++ 5.11编译器。
实验流程如下:1.首先定义了一个进程的结构体,其中包括了进程的名称、进程需要执行的时间片以及已经执行的时间片。
2.定义一个队列来存储进程,为了方便起见,队列采用了循环存储结构。
3.在主函数中,首先输入需要执行的进程数和一个时间片长度,接着依次输入每个进程的名称和需要执行的时间。
程序会根据输入的信息初始化进程,并将进程加入队列。
4.最后,程序开始模拟调度器的调度过程。
每次从队列中取出一个进程,将其执行时间减去一个时间片。
如果执行时间为0,则代表该进程已经完成任务,将其移出队列。
如果执行时间大于0,则将该进程重新加入队列尾部,然后下一个进程开始执行。
结果分析:在进行实验的过程中,我们发现时间片轮转调度算法可以很好地实现多进程的调度。
通过不断地轮转时间片,每个进程都有机会被执行。
此外,该算法具有良好的响应时间和公平性,能够确保每个进程都能够在一定时间内执行一定的任务,从而提高了系统的利用率和效率。
算法优缺点:时间片轮转调度算法具有以下几个优点:1. 公平性:每个进程都能够在一定时间内获得相同的可执行时间。
2. 可控性:时间片长度可以根据需要自行改变。
3. 高效性:可以很好地支持多进程的调度,提高了系统的利用率和效率。
同时,该算法也存在一些缺点:1.时间片的长度可能对进程的执行效率产生影响,长度过长会导致进程轮转过于缓慢,降低了系统的响应速度,长度过短则会增加进程上下文切换的次数。
2. 由于算法本身的局限性,它可能无法解决一些与进程先后顺序等有关的问题,例如死锁或者资源争用等。
进程的调度实验报告(3篇)
第1篇一、实验目的通过本次实验,加深对操作系统进程调度原理的理解,掌握先来先服务(FCFS)、时间片轮转(RR)和动态优先级(DP)三种常见调度算法的实现,并能够分析这些算法的优缺点,提高程序设计能力。
二、实验环境- 编程语言:C语言- 操作系统:Linux- 编译器:GCC三、实验内容本实验主要实现以下内容:1. 定义进程控制块(PCB)结构体,包含进程名、到达时间、服务时间、优先级、状态等信息。
2. 实现三种调度算法:FCFS、RR和DP。
3. 创建一个进程队列,用于存储所有进程。
4. 实现调度函数,根据所选算法选择下一个执行的进程。
5. 模拟进程执行过程,打印进程执行状态和就绪队列。
四、实验步骤1. 定义PCB结构体:```ctypedef struct PCB {char processName[10];int arrivalTime;int serviceTime;int priority;int usedTime;int state; // 0: 等待,1: 运行,2: 完成} PCB;```2. 创建进程队列:```cPCB processes[MAX_PROCESSES]; // 假设最多有MAX_PROCESSES个进程int processCount = 0; // 实际进程数量```3. 实现三种调度算法:(1)FCFS调度算法:```cvoid fcfsScheduling() {int i, j;for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[i].processName); processes[i].usedTime++;if (processes[i].usedTime == processes[i].serviceTime) { processes[i].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[i].processName); }for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```(2)RR调度算法:```cvoid rrScheduling() {int i, j, quantum = 1; // 时间片for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[i].processName); processes[i].usedTime++;processes[i].serviceTime--;if (processes[i].serviceTime <= 0) {processes[i].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[i].processName); } else {processes[i].arrivalTime++;}for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```(3)DP调度算法:```cvoid dpScheduling() {int i, j, minPriority = MAX_PRIORITY;int minIndex = -1;for (i = 0; i < processCount; i++) {if (processes[i].arrivalTime <= 0 && processes[i].priority < minPriority) {minPriority = processes[i].priority;minIndex = i;}}if (minIndex != -1) {processes[minIndex].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[minIndex].processName);processes[minIndex].usedTime++;processes[minIndex].priority--;processes[minIndex].serviceTime--;if (processes[minIndex].serviceTime <= 0) {processes[minIndex].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[minIndex].processName); }}}```4. 模拟进程执行过程:```cvoid simulateProcess() {printf("请选择调度算法(1:FCFS,2:RR,3:DP):");int choice;scanf("%d", &choice);switch (choice) {case 1:fcfsScheduling();break;case 2:rrScheduling();break;case 3:dpScheduling();break;default:printf("无效的调度算法选择。
时间片轮转调度算法实验报告
时间片轮转调度算法实验报告一、引言时间片轮转调度算法是一种常见的操作系统调度算法,它的主要思想是将CPU时间分成若干个时间片,每个进程在一个时间片内执行一定的时间,然后切换到下一个进程执行。
本实验通过使用C语言模拟实现时间片轮转调度算法,并对其进行评估和比较,以便更好地理解该调度算法的性能和特点。
二、实验目的1.理解时间片轮转调度算法的原理和实现方式;2.实现一个简单的时间片轮转调度算法模拟程序;3.比较时间片长度对调度算法性能的影响;4.分析时间片轮转调度算法的优缺点。
三、实验过程1.设计数据结构和算法在开始实验之前,我们首先需要设计数据结构和算法。
在本实验中,我们使用一个队列来表示就绪队列,并使用一个指针来标记当前执行的进程。
2.实现时间片轮转调度算法模拟程序根据设计的数据结构和算法,我们使用C语言编写了一个简单的时间片轮转调度算法模拟程序。
程序首先会要求用户输入进程数量和每个进程的执行时间,然后根据输入的信息,使用时间片轮转调度算法对进程进行调度并统计各个进程的等待时间和周转时间。
3.进行实验和分析我们进行了多组实验,通过改变时间片的长度,观察时间片轮转调度算法的性能。
并对实验结果进行统计和分析,比较不同时间片长度下的平均等待时间和平均周转时间。
四、实验结果和分析在本节,我们将介绍实验的结果和分析。
1.实验结果我们使用不同时间片长度进行了多组实验,得到了如下的结果:时间片长度,平均等待时间,平均周转时间------------,-------------,-------------1,5,152,3,134,2,128,1,112.结果分析通过对实验结果的分析,我们可以得出以下结论:-随着时间片长度的增加,进程的平均等待时间和平均周转时间都呈现下降的趋势。
这是因为时间片越长,每个进程执行的时间就越长,进程切换的次数就越少,从而提高了系统的效率。
-当时间片长度较小时,进程的平均等待时间和平均周转时间较长。
时间片轮转法完成进程调度(操作系统实验报告)
时间片轮转法完成进程调度【实验目的】(1)加深对进程的理解(2)理解进程控制块的结构(3)理解进程运行的并发性(4)掌握时间片轮转法进程调度算法【实验内容】(1)建立进程控制块(2)设计三个链队列.分别表示运行队列、就绪队列和完成队列(3)用户输入进程标识符以及进程所需的时间.申请空间存放进程PCB信息。
(4)每一个时间片结束输出各进程的进程号.CPU时间(即已经占用的CPU时间).所需时间(即还需要的CPU时间).以及状态(即用W表示等待.R表示运行.F表示完成)【程序代码】#include "stdio.h"#include"stdlib.h"struct PCB{int pid; //进程标识符int rr; //已运行时间int time; //进程要求运行时间char sta; //进程的状态struct PCB *next; //链接指针};struct PCB pcb1,pcb2,pcb3,pcb4,pcb5,*tail,*head,*rp;init(){int i,time;pcb1.pid = 1;pcb2.pid = 2;pcb3.pid = 3;pcb4.pid = 4;pcb5.pid = 5;pcb1.rr =pcb2.rr =pcb3.rr =pcb4.rr =pcb5.rr = 0;pcb1.sta = pcb2.sta = pcb3.sta = pcb4.sta = pcb5.sta = 'w'; printf("请输入时间片p1需要运行的时间:");scanf("%d",&time);pcb1.time = time;printf("请输入时间片p2需要运行的时间:");scanf("%d",&time);pcb2.time = time;printf("请输入时间片p3需要运行的时间:");scanf("%d",&time);pcb3.time = time;printf("请输入时间片p4需要运行的时间:");scanf("%d",&time);pcb4.time = time;printf("请输入时间片p5需要运行的时间:");scanf("%d",&time);pcb5.time = time;pcb1.next=&pcb2;pcb2.next=&pcb3;pcb3.next=&pcb4;pcb4.next=&pcb5;pcb5.next=&pcb1;head = &pcb1;tail = &pcb5;}void printf1(){printf("+---------------|---------------|---------------|---------------+\n");printf("|\tpid\t|\trr\t|\ttime\t|\tSTA\t|\n");printf("|---------------|---------------|---------------|---------------|\n");}printf2(){printf("processes p%d running\n",head->pid);printf1();printf("|\t%d\t|\t%d\t|\t%d\t|\t%c\t|\n",head->pid,head->rr,head->time,head->sta);printf("|---------------|---------------|---------------|---------------|\n");rp=head;while(rp!=tail){rp=rp->next;printf("|\t%d\t|\t%d\t|\t%d\t|\t%c\t|\n",rp->pid,rp->rr,rp->time,rp->sta);printf("|---------------|---------------|---------------|---------------|\n");}}operation(){int flag=1;while (flag<=5){head->rr ++;if ((head->rr==head->time)||(head->time==0)){tail->sta='w';head->sta='f';printf2();head=head->next;tail->next=head;flag++;}else{tail->sta='w';head->sta='r';printf2();tail=head;head=head->next;}}}void main(){init(); //初始化printf("this is the begin state :\n"); printf2(); //显示初始状态operation(); //运行}【结果截图】。
调度算法的实验报告
一、实验目的1. 理解操作系统调度算法的基本原理和概念。
2. 掌握几种常见调度算法的原理和实现方法。
3. 分析不同调度算法的性能特点,为实际应用提供参考。
二、实验内容本次实验主要涉及以下几种调度算法:先来先服务(FCFS)、最短作业优先(SJF)、优先级调度(Priority Scheduling)、最高响应比优先(HRRN)和时间片轮转(Round Robin)。
1. 先来先服务(FCFS)调度算法FCFS调度算法按照进程到达就绪队列的顺序进行调度,先到达的进程先执行。
该算法简单易实现,但可能导致长作业等待时间过长,从而降低系统吞吐量。
2. 最短作业优先(SJF)调度算法SJF调度算法优先选择执行时间最短的进程进行调度。
该算法可以最大程度地减少平均等待时间和平均周转时间,但可能导致长作业等待时间过长。
3. 优先级调度(Priority Scheduling)算法优先级调度算法为每个进程设置一个优先级,优先选择优先级高的进程进行调度。
该算法可以满足高优先级作业的需求,但可能导致低优先级作业长时间等待。
4. 最高响应比优先(HRRN)调度算法HRRN调度算法为每个进程设置一个响应比,优先选择响应比高的进程进行调度。
响应比是作业的等待时间与作业所需时间的比值。
该算法综合考虑了作业的等待时间和所需时间,是一种较为公平的调度算法。
5. 时间片轮转(Round Robin)调度算法时间片轮转调度算法将CPU时间划分为固定的时间片,按照进程到达就绪队列的顺序,每次只允许一个进程运行一个时间片。
如果进程在一个时间片内无法完成,则将其放入就绪队列的末尾,等待下一次调度。
该算法可以平衡各个进程的执行时间,但可能导致进程响应时间较长。
三、实验步骤1. 编写一个进程调度程序,实现上述五种调度算法。
2. 生成一个包含多个进程的作业队列,每个进程具有到达时间、所需运行时间和优先级等信息。
3. 分别采用五种调度算法对作业队列进行调度,并记录每个进程的执行情况。
操作系统实验报告——时间片调度轮转算法
操作系统实验报告第一次实验——时间片调度轮转算法实验时间:2014.11.7院系:计算机科学与技术学院班级:软件2班实验要求:(1)实验选题:时间片调度轮转算法(2)程序流程图及程序代码程序代码:#include<stdio.h>#include<conio.h>#define N 20typedef struct pcb{char pname[N];int runtime;int arrivetime;char state;struct pcb*next;}PCB;PCB head_input;PCB head_run;PCB * pcb_input;static char R='r',C='c'; unsigned long current;void inputprocess();int readyprocess();int readydata();int runprocess();FILE *f;int readyprocess(){while(1){if(readydata()==0)return 1;elserunprocess();}}int readydata(){if(head_input.next==NULL){if(head_run.next==NULL)return 0;elsereturn 1;}PCB *p1,*p2,*p3;p1=head_run.next;p2=&head_run;while(p1!=NULL){p2=p1;p1=p2->next;}p1=p2;p3=head_input.next;p2=&head_input;while(p3!=NULL){if(((unsigned long)p3->arrivetime<=current)&&(p3->state==R)){printf("时间片为%8d(时间%4d);进程%s 开始,\n",current,(current+500)/1000,p3->pname);fprintf(f,"时间片为%8d(时间%4d);进程%s 开始,\n",current,(current+500)/1000,p3->pname);p2->next=p3->next;p3->next=p1->next;p1->next=p3;p3=p2;}p3=p3;p3=p3->next;}return 1;}int runprocess(){PCB *p1,*p2;if(head_run.next==NULL){current++;return 1;}else{p1=head_run.next;p2=&head_run;while(p1!=NULL){p1->runtime--;current++;if(p1->runtime<=0){printf("时间片为%8d 时间%4d 进程%s 结束.\n",current,(current+500)/1000,p1->pname);fprintf(f,"时间片为%8d 时间%4d 进程%s 结束.\n",current,(current+500)/1000,p1->pname);p1->state=C;p2->next=p1->next;delete p1;p1=NULL;}else{p2=p1;p1=p2->next;}}return 1;}}void inputprocess(){PCB *p1,*p2;int num;unsigned long max=0;printf("请输入进程的数量:");fprintf(f,"请输入进程的数量:");scanf("%d",&num);fprintf(f,"%d\n",&num);p1=&head_input;p2=p1;p1->next=new PCB;p1=p1->next;for(int i=0;i<num;i++){printf("请输入第%d个进程的进程名:",i+1);fprintf(f,"请输入第%d个进程的进程名:",i+1);scanf("%s",p1->pname);fprintf(f,"%s\n",p1->pname);printf("它的运行时间为:");fprintf(f,"它的运行时间为:");scanf("%d",&(p1->runtime));fprintf(f,"%d\n",&(p1->runtime));printf("它的到达时间为:");fprintf(f,"它的到达时间为:");scanf("%d",&(p1->arrivetime));fprintf(f,"%d\n",&(p1->arrivetime));p1->runtime=(p1->runtime)*1000;p1->arrivetime=(p1->arrivetime)*1000;p1->state=R;if((unsigned long)(p1->arrivetime)>max)max=p1->arrivetime;p1->next=new PCB;p2=p1;p1=p1->next;}delete p1;p1=NULL;p2->next=NULL;}void main(){f=fopen("result.txt","w");printf("时间1=1000 时间片\n");fprintf(f,"\ntime 1=1000 time slice\n");current=0;inputprocess();readyprocess();getch();fclose(f);}(3)PCB数据结构typedef struct pcb{char pname[N];int runtime;int arrivetime;char state;struct pcb*next;}PCB;(4)程序运行结果(5)总结掌握了时间片轮转调度算法,时间片的大小确定很重要。
时间片轮转进程调度实验报告
时间片轮转进程调度实验报告实验目的通过实验,掌握时间片轮转调度算法的原理和实现方法,了解进程调度的过程,掌握进程调度的基本要素和调度过程,并能够通过编程实现时间片轮转调度算法。
实验要求1. 理解时间片轮转调度的基本原理;2. 编程实现时间片轮转进程调度算法;3. 运行程序,观察并分析进程的执行情况。
实验设备计算机一台,支持多进程操作系统。
实验原理时间片轮转调度算法是一种基于时间片的进程调度算法,主要应用于多道程序环境下。
它的基本原理是将CPU的运行时间划分为一段段的时间片,在每个时间片结束时,如果进程还未完成,就将该进程挂起,将CPU分配给下一个进程执行。
通过快速切换进程,使得每个进程都能平等地获得CPU时间。
实验过程1. 定义进程控制块(PCB)的数据结构,包括进程的ID、优先级、状态、已执行时间等;2. 定义进程队列的数据结构,使用循环队列实现,用于存储待调度的进程;3. 初始化进程队列,将待调度的进程加入队列中;4. 设置时间片大小;5. 开始执行进程调度算法:a) 从队列中取出一个进程,将其状态设置为运行状态;b) 执行该进程,计算其已执行时间;c) 如果已执行时间小于时间片大小,将进程重新加入队列;d) 如果已执行时间等于时间片大小,将进程的状态设置为挂起,并将其放回队列;6. 重复步骤5,直到队列中所有进程都执行完毕。
实验结果运行该程序,可以观察到进程按照时间片轮转调度算法依次执行,每个进程都能获得一段时间的CPU执行时间,保证了进程执行的公平性。
实验总结通过本次实验,我深入了解了时间片轮转调度算法的原理和实现方法。
时间片轮转调度算法采用了循环队列的数据结构,通过设置时间片大小来控制进程的执行时间。
该算法能够使进程获得公平的CPU时间,并且能够保证每个进程都能得到一定的执行时间。
这在多道程序环境下非常重要,可以避免某个进程长时间占用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函数对结果进行格式输出。
操作系统实验报告时间片轮转调度算法
操作系统实验报告时间片轮转调度算法“网络协议分析”实验4实验名称:用Ethereal研究DNS和HTTP协议实验目的:通过对捕获分组的分析和研究,加深对DNS协议和HTTP协议的工作原理和实现过程的理解。
实验环境:连网PC机,Ethereal网络协议分析软件实验步骤:1.安装Ethereal网络协议分析器。
2.打开Ethereal软件菜单中的Help->Contents,可学习Ethereal的使用方法。
3.开始捕获分组之前,清空客户端Web浏览器的高速缓存和DNS的高速缓存(命令为:ipconfig /flushdns)。
(想一想,为什么?)4.在Capture->Option里选择网卡类型;取消捕获分组的“混杂模式”;设置捕获过滤器为:“host 本机IP”,这样Ethereal就会只捕获从本机发出的和发往本机的分组。
5.点击Start启动协议分析器,用Ethereal捕获从本机发出和发往本机的分组。
6.在Web浏览器中输入URL(如.cn, 等,网页较简单)。
网页显示出来后,过一会儿停止捕获。
将跟踪文件保存在一个文件中。
实验结果分析:1.在跟踪列表框中找出请求网页时发出的DNS查询报文和回答报文,找出发起TCP连接的三次握手报文,找出HTTP请求报文和响应报文。
2.在协议框中找出各层协议,观察各层协议,并对照教材中DNS查询/回答报文结构和HTTP请求/响应报文结构对这些应用层报文进行分析,找出报文中各字段相应的内容,解释其含义和用途。
3.你的主机所用的DNS服务器的IP地址是多少?你的浏览器与DNS服务器之间使用传输层的什么协议进行通信?202.196.0.1DNS请求报文和应答报文的ID号一样吗?是什么?一样,0xc4a6你所请求网站的规范名是什么?mail.DNS服务器对你的域名解析请求在应答中给出了几个可用的IP地址?都是什么?2个,202.196.0.16,202.196.0.17和DNS服务器通信时,你的客户机使用的端口号是多少?DNS服务器使用的端口号是多少?64384,53你所请求Web服务器的IP地址是什么?其域名有几个层次(参看教材127页)?202.196.0.16 4个如果请求一个存在/不存在的网页,Web服务器分别会应答什么? ??等等。
实验一 时间片轮转进程调度算法
实验一时间片轮转进程调度算法时间片轮转是一种常用的进程调度算法,它的基本思想是将CPU的使用时间分成若干个时间片,每个进程在一个时间片内运行一段时间。
当一个时间片用完后,就将当前进程放入就绪队列的末尾,然后选择就绪队列中的下一个进程来执行。
下面是一个简单的时间片轮转算法的实验:1. 首先,定义一个进程结构体,包括进程ID、执行时间、剩余时间等属性。
```c++struct Process {int id; // 进程IDint executionTime; // 执行时间int remainingTime; // 剩余时间Process(int id, int executionTime) {this->id = id;this->executionTime = executionTime;this->remainingTime = executionTime;}};```2. 定义一个就绪队列,用于存放所有待执行的进程。
```c++queue<Process> readyQueue;```3. 定义一个时间片大小,例如设为1。
```c++int timeSlice = 1;```4. 创建一些进程,并将它们加入就绪队列。
```c++Process p1(1, 5);Process p2(2, 3);Process p3(3, 2);Process p4(4, 4);readyQueue.push(p1);readyQueue.push(p2);readyQueue.push(p3);readyQueue.push(p4);```5. 开始执行进程调度。
```c++while (!readyQueue.empty()) {Process currentProcess = readyQueue.front(); // 获取当前要执行的进程readyQueue.pop(); // 从就绪队列中移除当前进程// 执行当前进程,更新剩余时间if (currentProcess.remainingTime > timeSlice) {currentProcess.remainingTime -= timeSlice;readyQueue.push(currentProcess); // 将剩余时间不为0的进程重新放入就绪队列} else {currentProcess.remainingTime = 0;cout << "进程" << currentProcess.id << "执行完毕。
时间片轮转调度算法实验报告
******************************************** 测试数据2:2 3 11 2 35 4 2测试数据3:【结论】(结果)测试数据1的运行结果(截图):测试数据2的运行结果:测试数据3的运行结果:源程序代码:#include"stdio.h"#include"stdlib.h" struct stud{错误分析:链表初始化排序过程中:指针p=Null时,不能执行q->arrive等命令;错误解决方法:将while(q->arrive<p->arrive &&q){t=q;q=q->next;}改为:while(q&&q->arrive<p->arrive){t=q;q=q->next;}2、进程运行时间大于时间片时,程序进入死循环:当进程所需时间等于时间片时,运行结果正确:进程运行时间大于时间片时,程序进入死循环:错误分析:进程所需剩余时间计算错误;错误修改:即进入死循环。
当进程所需时间小于时间片时,应立即跳出进程就绪对列。
错误修改:在output()子函数中p->rest=p->rest-slice;后面加上一个语句:if(p->rest<0)p->rest=0;实验运行结果为:实验的体会及收获:通过这次试验,我对处理机的调度算法---基于时间片轮转调度算法思想有了更深的理解;另外使我对链表的知识有了更深的理解,而且锻炼了我的思维能力,使我能更全面地思考问题,以后还需要多做些这方面的练习。
实验还需改进之处:为考虑进程所需时间小于时间片大小的情况,如:进程运行完一次时间片时间中断后,但下一个进程的提交时间要迟很多,这时候就会浪费很多时间等待,这是该程序还需改进的地方。
另外,本实验中的RR算法的时间片大小固定,所以实际是属于基本轮转法,还有种是时间片长短是变化的,即改进轮转法。
时间片轮转实验报告
实验二时间片轮转一、实验目的弄明白时间片轮转的工作流程和原理,通过实验让自己更明白切身体会的深!时间片轮转主要是解决处理机调度进程时的优化!正确理解提高处理机的利用率及改善系统性能在很大程度上取决于处理机调度性能的好坏,在操作系统中调度的实质是一种资源分配,调度算法是指根据系统的资源分配策略规定的资源分配算法,对不同的系统和系统目标,应采用不的调度算法。
在多道程序或多任务系统中,系统同时处于就绪状态的进程有若干个。
也就是说能运行的进程数远远大于处理机个数。
为了使系统中的各进程能有条不紊地运行,必须选择某种调度策略,以选择一进程占用处理机。
通过本实验,加深对处理机调度的理解。
弄明白时间片轮转的工作流程和原理,通过实验让自己更明白切身体会的深!二、实验内容及要求试验内容就是按照时间片工作原理:时间片轮转的原则是系统将所有的就绪进程按照先来先服务的原则排成一个队列,每次调度时,把CPU分配对手进程,并令其执行一个时间片,当执行完时,有一个计时器发出时钟中断请求,该进程停止,并被送到就绪队列的末尾,然后再把处理机分配就绪队列的队列进程,同时也让它执行一个时间片!要求:1:在开始页面用户可输入进程名,给出时间片的大小和每个进程的服务时间。
2:每运行一次,给进程的服务时间减去一个时间片大小排到队尾,显示一个时间片后的新队列。
3:直到所有的进程都服务完。
三、实验感想本实验的难点是每执行一个时间片就让它排到队尾,也即重新排序,并从头开始调度执行!时间片的工作流程是:时间片轮转的原则是系统将所有的就绪进程按照先来先服务的原则排成一个队列,每次调度时,把CPU分配对手进程,并令其执行一个时间片,当执行完时,有一个计时器发出时钟中断请求,该进程停止,并被送到就绪队列的末尾,然后再把处理机分配就绪队列的队列进程,同时也让它执行一个时间片!通过亲手实验,对上述写的时间片的工作流程和原理有了更贴切的认识!本次实验遇到了很大的麻烦,及时大部分代码是借鉴网上的,但自己通过修改,来获取自己想要的,在自己的努力和同学的帮助下终于调试正确!很是高兴!。
实验一 时间片轮转进程调度算法
实验一时间片轮转进程调度算法时间片轮转(Round Robin)是一种常见的进程调度算法,其核心思想是每个进程被分配一个时间片,当时间片用完时,CPU会切换到下一个进程。
这种算法简单高效,能够保证每个进程都能获得公平的CPU时间。
在时间片轮转算法中,每个进程被分配一个相同大小的时间片,通常为几十毫秒到几百毫秒不等。
当一个进程占用完了其时间片,CPU会将其放入就绪队列的末尾,并将CPU分配给队列中的下一个进程。
这种方式可以确保每个进程都有机会运行,并且不会出现某个进程长时间占用CPU,导致其他进程饥饿的情况。
时间片轮转算法的优点之一是简单易实现,只需要设置一个固定的时间片大小和一个就绪队列即可。
另外,由于每个进程都有相同的时间片,因此可以较好地保证公平性,避免某个进程长时间占用CPU而导致其他进程无法运行的情况。
然而,时间片轮转算法也存在一些缺点。
首先,如果时间片设置过小,会导致频繁的进程切换,增加了系统的开销。
而如果时间片设置过大,可能会出现某些进程长时间占用CPU的情况,降低了系统的响应速度。
因此,选择合适的时间片大小对系统的性能至关重要。
另外,时间片轮转算法对I/O密集型的进程并不友好。
由于I/O操作需要等待外部设备的响应,进程可能会在I/O操作期间主动放弃CPU,这样会导致进程在等待I/O时浪费了部分时间片。
为了解决这个问题,可以考虑将I/O操作的等待时间纳入时间片,或者采用其他更适合I/O密集型进程的调度算法。
总的来说,时间片轮转算法是一种简单高效的进程调度算法,适用于大多数情况下。
在实际应用中,需要根据系统的特点和需求选择合适的时间片大小,以提高系统的性能和响应速度。
同时,针对不同类型的进程可以结合其他调度算法,以达到更好的效果。
调度算法实验报告总结(3篇)
第1篇一、实验目的本次实验旨在通过模拟操作系统中的进程调度过程,加深对进程调度算法的理解。
实验中,我们重点研究了先来先服务(FCFS)、时间片轮转(RR)和动态优先级调度(DP)三种常见的调度算法。
通过编写C语言程序模拟这些算法的运行,我们能够直观地观察到不同调度策略对进程调度效果的影响。
二、实验内容1. 数据结构设计在实验中,我们定义了进程控制块(PCB)作为进程的抽象表示。
PCB包含以下信息:- 进程编号- 到达时间- 运行时间- 优先级- 状态(就绪、运行、阻塞、完成)为了方便调度,我们使用链表来存储就绪队列,以便于按照不同的调度策略进行操作。
2. 算法实现与模拟(1)先来先服务(FCFS)调度算法FCFS算法按照进程到达就绪队列的顺序进行调度。
在模拟过程中,我们首先将所有进程按照到达时间排序,然后依次将它们从就绪队列中取出并分配CPU资源。
(2)时间片轮转(RR)调度算法RR算法将CPU时间划分为固定的时间片,并按照进程到达就绪队列的顺序轮流分配CPU资源。
当一个进程的时间片用完时,它将被放入就绪队列的末尾,等待下一次调度。
(3)动态优先级调度(DP)算法DP算法根据进程的优先级进行调度。
在模拟过程中,我们为每个进程分配一个优先级,并按照优先级从高到低的顺序进行调度。
3. 输出调度结果在模拟结束后,我们输出每个进程的调度结果,包括:- 进程编号- 到达时间- 运行时间- 等待时间- 周转时间同时,我们还计算了平均周转时间、平均等待时间和平均带权周转时间等性能指标。
三、实验结果与分析1. FCFS调度算法FCFS算法简单易实现,但可能会导致进程的响应时间较长,尤其是在存在大量短作业的情况下。
此外,FCFS算法可能导致某些进程长时间得不到调度,造成饥饿现象。
2. 时间片轮转(RR)调度算法RR算法能够有效地降低进程的响应时间,并提高系统的吞吐量。
然而,RR算法在进程数量较多时,可能会导致调度开销较大。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
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函数对结果进行格式输出。
3、详细设计实现程序模块的具体算法。
void RRAlgorithm(){char processMoment[100]; //存储每个时间片p对应的进程名称RRqueue.push(RRarray[0]);int processMomentPoint = 0;int CurrentTime=0;int tempTime; //声明此变量控制CurrentTime的累加时间,当前进程的服务时间小于时间片q的时候,起到重要作用int i=1; //指向还未处理的进程的下标int finalProcessNumber = 0; //执行RR算法后,进程的个数int processTime[50];//CurrentTime的初始化if (RRarray[0].ServiceTime>=q){CurrentTime = q;}else{CurrentTime = RRarray[0].ServiceTime;}while(!RRqueue.empty()){for (int j=i;j<n;j++) //使得满足进程的到达时间小于当前时间的进程都进入队列{if (RRarray[j].name!=NULL && CurrentTime >= RRarray[j].ArrivalTime){RRqueue.push(RRarray[j]);i++;}}if (RRqueue.front().ServiceTime<q){tempTime = RRqueue.front().ServiceTime;}else{tempTime = q;}RRqueue.front().ServiceTime -= q; //进程每执行一次,就将其服务时间-q//将队首进程的名称放入数组中processMoment[processMomentPoint] = RRqueue.front().name;processMomentPoint++;processTime[finalProcessNumber] = tempTime;finalProcessNumber++;if (RRqueue.front().ServiceTime <= 0) //把执行完的进程退出队列{//RRqueue.front().FinishedTime = CurrentTime;RRqueue.pop(); //如果进程的服务时间小于等于,即该进程已经服务完了,将其退栈}else{//将队首移到队尾RRqueue.push(RRqueue.front());RRqueue.pop();}CurrentTime += tempTime;}//进程输出处理每个时间段对应的执行的进程cout<<"各进程的执行时刻信息:"<<endl;cout<<" "<<"0时刻--> "<<setw(2)<<processTime[0]<<"时刻";processTime[finalProcessNumber]=0;int time = processTime[0];int count = 0;for (i=0;i<finalProcessNumber;i++){count = 0;cout<<setw(3)<<processMoment[i]<<setw(3)<<endl;while(RRarray[count].name!=processMoment[i] && count<n){count++;}RRarray[count].FinishedTime = time;if (i<finalProcessNumber - 1){cout<<setw(3)<<time<<"时刻"<<" --> "<<setw(2)<<time + processTime[i+1]<<"时刻"<<setw(3);time += processTime[i+1];}}cout<<endl;//周转时间、带权周转时间、平均周转时间、带权平均周转时间的计算//1. 周转时间= 完成时间- 到达时间//2. 带权周转时间= 周转时间/服务时间for ( i=0;i<n;i++){RRarray[i].WholeTime = RRarray[i].FinishedTime - RRarray[i].ArrivalTime;RRarray[i].WeightWholeTime = (double)RRarray[i].WholeTime/RRarray[i].ServiceTime;}double x=0,y=0;for (i=0;i<n;i++){x += RRarray[i].WholeTime;y += RRarray[i].WeightWholeTime;}AverageWT = x/n;AverageWWT = y/n;}4、调试分析(1)调试过程中遇到的问题以及解决方法,设计与实现的回顾讨论和分析在算法设计时,由于一开始不知道如何将位于队首的进程,在执行完后如何移至队尾进行循环,所以思考了很久,后来想到将队首进程进行重新压入队列从而解决了此问题。
(2)算法的性能分析每个进程被分配一个时间段,即该进程允许运行的时间。
如果在时间片结束时进程还在运行,则CPU将被剥夺并分配给另一个进程。
如果进程在时间片结束前阻塞或结束,则CPU当即进行切换。
调度程序所要做的就是维护一张就绪进程列表,当进程用完它的时间片后,它被移到队列的末尾。
(3)经验体会通过本次实验,深入理解了时间片轮转RR进程调度算法的思想,培养了自己的动手能力,通过实践加深了记忆。
5、用户使用说明程序的使用说明,列出每一步的操作步骤。
7、附录带注释的源程序,注释应清楚具体#include <iostream>#include <queue>#include <iomanip>#include <fstream>#define MaxNum 100using namespace std;typedef struct{char name;int ArrivalTime;int ServiceTime;int FinishedTime;int WholeTime;double WeightWholeTime;}RR;static queue<RR>RRqueue; //声明一个队列static double AverageWT =0,AverageWWT=0; static int q; //时间片static int n; //进程个数static RR RRarray[MaxNum]; //进程结构void Input(){//文件读取模式ifstream inData;inData.open("./data4.txt");//data.txt表示q = 4的RR调度算法//data2.txt表示q = 1的RR调度算法inData>>n;inData>>q;for (int i=0;i<n;i++){inData>>RRarray[i].name;}for (i=0;i<n;i++){inData>>RRarray[i].ArrivalTime;}for (i=0;i<n;i++){inData>>RRarray[i].ServiceTime;}//用户输入模式cout<<"************************************************************** **"<<endl;cout<<"请输入进程个数n :";cin>>n;cout<<"请输入时间片q :";cin>>q;cout<<"请按到达时间的顺序依次输入进程名:"<<endl;for (i=0;i<n;i++){cin>>RRarray[i].name;}cout<<"请从小到大输入进程到达时间:"<<endl;for (i=0;i<n;i++){cin>>RRarray[i].ArrivalTime;}cout<<"请按到达时间的顺序依次输入进程服务时间:"<<endl;for (i=0;i<n;i++){cin>>RRarray[i].ServiceTime;}cout<<"************************************************************** **"<<endl;//输出用户所输入的信息cout<<"The information of processes is the following:"<<endl;cout<<setw(10)<<"进程名"<<" ";cout<<setw(10)<<"到达时间"<<" ";cout<<setw(10)<<"服务时间"<<" "<<endl;for ( i=0;i<n;i++){cout<<setw(10)<<RRarray[i].name<<" ";cout<<setw(10)<<RRarray[i].ArrivalTime<<" ";cout<<setw(10)<<RRarray[i].ServiceTime<<" "<<endl;}cout<<"************************************************************** **"<<endl;}void RRAlgorithm(){char processMoment[100]; //存储每个时间片p对应的进程名称RRqueue.push(RRarray[0]);int processMomentPoint = 0;int CurrentTime=0;int tempTime; //声明此变量控制CurrentTime的累加时间,当前进程的服务时间小于时间片q的时候,起到重要作用int i=1; //指向还未处理的进程的下标int finalProcessNumber = 0; //执行RR算法后,进程的个数int processTime[50];//CurrentTime的初始化if (RRarray[0].ServiceTime>=q){CurrentTime = q;}else{CurrentTime = RRarray[0].ServiceTime;}while(!RRqueue.empty()){for (int j=i;j<n;j++) //使得满足进程的到达时间小于当前时间的进程都进入队列{if (RRarray[j].name!=NULL && CurrentTime >= RRarray[j].ArrivalTime){RRqueue.push(RRarray[j]);i++;}}if (RRqueue.front().ServiceTime<q){tempTime = RRqueue.front().ServiceTime;}else{tempTime = q;}RRqueue.front().ServiceTime -= q; //进程每执行一次,就将其服务时间-q//将队首进程的名称放入数组中processMoment[processMomentPoint] = RRqueue.front().name;processMomentPoint++;processTime[finalProcessNumber] = tempTime;finalProcessNumber++;if (RRqueue.front().ServiceTime <= 0) //把执行完的进程退出队列{//RRqueue.front().FinishedTime = CurrentTime;RRqueue.pop(); //如果进程的服务时间小于等于,即该进程已经服务完了,将其退栈}else{//将队首移到队尾RRqueue.push(RRqueue.front());RRqueue.pop();}CurrentTime += tempTime;}//进程输出处理每个时间段对应的执行的进程cout<<"各进程的执行时刻信息:"<<endl;cout<<" "<<"0时刻--> "<<setw(2)<<processTime[0]<<"时刻";processTime[finalProcessNumber]=0;int time = processTime[0];int count = 0;for (i=0;i<finalProcessNumber;i++){count = 0;cout<<setw(3)<<processMoment[i]<<setw(3)<<endl;while(RRarray[count].name!=processMoment[i] && count<n){count++;}RRarray[count].FinishedTime = time;if (i<finalProcessNumber - 1){cout<<setw(3)<<time<<"时刻"<<" --> "<<setw(2)<<time + processTime[i+1]<<"时刻"<<setw(3);time += processTime[i+1];}}cout<<endl;//周转时间、带权周转时间、平均周转时间、带权平均周转时间的计算//1. 周转时间= 完成时间- 到达时间//2. 带权周转时间= 周转时间/服务时间for ( i=0;i<n;i++){RRarray[i].WholeTime = RRarray[i].FinishedTime - RRarray[i].ArrivalTime;RRarray[i].WeightWholeTime = (double)RRarray[i].WholeTime/RRarray[i].ServiceTime;}double x=0,y=0;for (i=0;i<n;i++){x += RRarray[i].WholeTime;y += RRarray[i].WeightWholeTime;}AverageWT = x/n;AverageWWT = y/n;}void display(){cout<<"******************************************************"<<endl;cout<<"RR调度算法执行后:进程相关信息如下:"<<endl;cout<<setw(10)<<"进程名(ID)"<<" ";cout<<setw(10)<<"到达时间"<<" ";cout<<setw(10)<<"服务时间"<<" ";cout<<setw(10)<<"完成时间"<<" ";cout<<setw(10)<<"周转时间"<<" ";cout<<setw(10)<<"带权周转时间"<<endl;for (int i = 0;i<n;i++){cout<<setw(10)<<RRarray[i].name<<" ";cout<<setw(10)<<RRarray[i].ArrivalTime<<" ";cout<<setw(10)<<RRarray[i].ServiceTime<<" ";cout<<setw(10)<<RRarray[i].FinishedTime<<" ";cout<<setw(10)<<RRarray[i].WholeTime<<" ";cout<<setw(10)<<RRarray[i].WeightWholeTime<<" "<<endl;;}cout<<"所有进程的平均周转时间= "<<AverageWT<<endl;cout<<"所有进程的平均带权周转时间= "<<AverageWWT<<endl;cout<<"******************************************************"<<endl; }int main(){Input();RRAlgorithm();display();return 0;}。