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

合集下载

实验二带优先级的时间片轮换的进程调度算法的实现

实验二带优先级的时间片轮换的进程调度算法的实现


struct pcb *p;

for (i=0;i<MAXPIOR;i++)

{p=array[i];

while (p!=NULL)

{printf("id:%d,state:%d,pior:%d,life:%d\n",p->ident,p->state,p->pior,p->life);

p=p->next;
• {int i=0,ii=0;
• for (i=0;i<7;i++)

if (stricmp(str,command[i])==0)

break;
• switch(i)

{case 0:printf("thank you for using the program!\n");exit(0);

break;
•{

int i=MAXPIOR-1,pior=0,t;

struct pcb *pp,*qq,*pr,*r;

do

{

while (i>=0 && array[i]==NUf (i<0)

{

printf("NO process,please create it! \n");
第1个,再降低其优先级,插入到相应的队列中。 C)ps 查看当前进程状态 D)sleep 命令将进程挂起 E)awake 命令唤醒1个被挂起的进程 F)kill 命令杀死进程 G)quit命令退出 (4)选用面向对象的编程方法。

实验二时间片轮转算法实验报告

实验二时间片轮转算法实验报告

实验二时间片轮转算法实验报告一、实验目的本次实验的主要目的是了解时间片轮转算法的工作原理,学习如何使用时间片轮转算法进行进程调度,并了解时间片大小对进程调度的影响。

二、实验原理时间片轮转算法是一种公平的进程调度算法,它采用循环队列的形式,将所有需要运行的进程按照到达时间排序,并将它们按照轮转的方式依次执行,每个进程在一个时间片内执行一定的时间(时间片大小),然后被暂停并放在队列的末尾等待下一次调度。

当一个进程的时间片用完后,它会被暂停并放在队列的最后,而在这个时间片内没有执行完的进程会被暂停并放到队列的开头,以便继续下一轮的运行。

这样一直循环下去,直到所有进程都运行完毕。

三、实验步骤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. 由于算法本身的局限性,它可能无法解决一些与进程先后顺序等有关的问题,例如死锁或者资源争用等。

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

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

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

【实验内容】问题描述:设计程序模拟进程的时间片轮转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)输出:要求输出计算出来的每个进程的周转时间,带权周转时间,所有进程的平均周转时间,带权平均周转时间。

实现提示:用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, … ,T n,S1, … ,S n;时间片大小q;按照时间片轮转RR算法进行进程调度,计算进程的完成时间、周转时间和带权周转时间;计算所有进程的平均周转时间和平均带权周转时间;按格式输出调度结果。

进程调度算法实验报告

进程调度算法实验报告

计算机操作系统实验报告实验二进程调度算法一、实验名称:进程调度算法二、实验内容:编程实现如下算法:1.先来先服务算法;2.短进程优先算法;3.时间片轮转调度算法。

三、问题分析与设计:1.先来先服务调度算法先来先服务调度算法是一种最简单的调度算法,该算法既可以用于作业调度,也可用于进程调度。

当在作业调度中采用该算法时,每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业,将他们调入内存,为它们分配资源、创建进程,然后放入就绪队列。

在进程调度中采用FCFS算法时,则每次调度是从就绪队列中选择一个最先进入该队列的进程,为之分配处理机,使之投入运行。

该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。

FCFS算法比较有利于长作业(进程),2.短作业(进程)优先调度算法短作业(进程)优先调度算法SJ(P)F,是指对短作业或短进程优先调度的算法。

它们可以分别用于作业调度和进程调度。

短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业,将它们调入内存运行。

而短进程(SPF)调度算法则是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机再重新调度。

SJ(P)F调度算法能有效地降低作业(进程)的平均等待时间,提高系统吞吐量。

该算法对长作业不利,完全未考虑作业的紧迫程度。

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

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

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

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

进程的调度实验报告(3篇)

进程的调度实验报告(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(); //运行}【结果截图】。

操作系统实验报告——时间片调度轮转算法

操作系统实验报告——时间片调度轮转算法

操作系统实验报告第一次实验——时间片调度轮转算法实验时间: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资源而导致其他进程无法得到执行的情况。

掌握了时间片轮转调度算法的理论和实现方法后,我能够更好地理解进程调度的过程,并能够通过编程实现对进程的调度。

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

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

郑州轻工业学院实验报告课程名称:操作系统姓名:学号:专业班级:任课教师:黄伟2016 年11 月 2 日实验报告成绩评定表实验报告正文实验二时间片轮转调度算法设计与实现一、实验目的目的:了解并掌握时间片轮转调度算法的理论,熟悉并掌握时间片设置的大小对系统的影响。

任务:模拟实现时间片轮转调度算法。

二、实验内容1.任务描述1)时间片轮转调度算法问题简介时间片轮转的主要思想就是按顺序为每一个进程一次只分配一个时间片的时间。

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

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

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

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

2)设计任务简介模拟实现时间片轮转调度算法,具体如下:设置进程体:进程名,进程的到达时间,服务时间,,进程状态(W——等待,R——运行,F——完成),进程间的链接指针进程初始化:由用户输入进程名、服务时间进行初始化,同时,初始化进程的状态为W。

显示函数:在进程调度前、调度中和调度后进行显示。

排序函数:对就绪状态的进程按照进入就绪队列的时间排序,新到达的进行应优先于刚刚执行过的进程进入就绪队列的队尾。

注意考虑到达时间调度函数:每次从就绪队列队首调度优一个进程执行,状态变化。

并在执行一个时间片后化,服务时间变化,状态变化。

当服务时间为0时,状态变为F。

删除函数:撤销状态为F的进行。

2.调度问题的表示方案首先每一个进程用一个进程控制块PCB来代表。

进程调度算法实验报告

进程调度算法实验报告

操作系统实验报告(二)实验题目:进程调度算法实验环境:C++实验目得:编程模拟实现几种常见得进程调度算法,通过对几组进程分别使用不同得调度算法,计算进程得平均周转时间与平均带权周转时间,比较各种算法得性能优劣.实验内容:编程实现如下算法:1、先来先服务算法;2、短进程优先算法;3、时间片轮转调度算法。

设计分析:程序流程图:1、先来先服务算法2、短进程优先算法3、时间片轮转调度算法实验代码:1.先来先服务算法#include <iostream、h〉#definen20typedef struct{int id;//进程名int atime; //进程到达时间intruntime; //进程运行时间}fcs;voidmain(){intamount,i,j,diao,huan;fcs f[n];cout<<”请输入进程个数:”<〈endl;cin>>amount;for(i=0;i<amount;i++){cout<<"请输入进程名,进程到达时间,进程运行时间:”〈<endl;cin>>f[i]、id;cin〉>f[i]、atime;cin〉〉f[i]、runtime;}for(i=0;i〈amount;i++)//按进程到达时间得先后排序{ //如果两个进程同时到达,按在屏幕先输入得先运行for(j=0;j〈amount—i—1;j++){if(f[j]、atime〉f[j+1]、atime){diao=f[j]、atime;f[j]、atime=f[j+1]、atime;f[j+1]、atime=diao;huan=f[j]、id;f[j]、id=f[j+1]、id;f[j+1]、id=huan;}}}for(i=0;i<amount;i++){cout〈<”进程:"<〈f[i]、id<〈”从"〈<f[i]、atime〈<”开始”〈<",”<<"在"〈〈f[i]、atime+f[i]、runtime<<”之前结束。

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

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

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;}四.调试分析在时间片大于所有进程的服务时间时,程序正常运行,当时间片小于某些进程的服务时间时,程序不能输出正确的运算结果。

操作系统实验报告时间片轮转调度算法

操作系统实验报告时间片轮转调度算法

操作系统实验报告时间片轮转调度算法“网络协议分析”实验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服务器分别会应答什么? ??等等。

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

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

******************************************** 测试数据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算法的时间片大小固定,所以实际是属于基本轮转法,还有种是时间片长短是变化的,即改进轮转法。

操作系统实验2进程调度 实验报告

操作系统实验2进程调度 实验报告
(1)掌握时间片轮换的进程调度算法;
(2)掌握带优先级的进程调度算法;
(3)选用面向对象的编程方法。
二、实验内容;
(1)用C语言(或其它语言,如Java)实现对N个进程采用动态优先调度算法的调度。
(2)每个用来标识进程的进程控制块PCB可用结构来描述,包括以下字段:
进程标识数ID。
进程优先数PRIORITY,并规定优先数越大的进程,其优先权越高。
4.可动态添加、删除进程;
5.完成所有进程操作。
五、程序源代码及注释
六、实验结果分析
1、运行结果如下:
2、结果分析
首先,每次从就绪队列中选择最高优先权的进程时,需要计算出最高优先权和次高优先权之间的STARTBLOCK。即最高优先权进程运行多少个时间片后就会进入阻塞队列。每调度一次,就需要更新所有进程的信息,并判断CPUTIME是否等于ALLTIME,如果相等,则进程完成操作,需从就绪队列中删除。如果阻塞队列中进程的BLOCKTIME为0时,还需要将其转移到就绪队列中。
(5)用户可以干预进程的运行状态,程序应该设置可以让用户中断的入口,并可以通过以下命令查看,修改,终止进程。
A)create随机创建进程,进程的优先级与所需要的时间片随机决定;
B)ps查看当前进程状态
C)sleep命令将进程挂起
D)kill命令杀死进程
E)quit命令退出
(5)分析程序运行的结果,谈一下自己的认识。
三、实验原理;
无论是在批处理系统还是分时系统中,用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。另外,系统进程也同样需要使用处理机。这就要求进程调度程序按一定的策略,动态地把处理机分配给处于就绪队列中的某一个进程,以使之执行。
根据进程的五个特征:(1)动态性;(2)并发性;(3)异步性;(4)独立性;(5)结构性及三种基本状态的转换,了解各进程对资源的共享和竞争。进程并发执行时,由于资源共享,带来各进程之间的相互制约。为了反映这些制约关系和资源共享关系,在创建一个进程时,应首先创建其PCB,然后才能根据PCB中信息对进程实施有效的管理和控制。当一个进程完成其功能之后,系统则最后释放PCB,进程也随之消亡。

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

实验二时间片轮转RR进程调度算法
四:调试分析
调试过程中遇到的问题即在时间片轮转算法中由于循环使用不当导致无法实现预期的结果,后通过问同学,网上查找资料解决。算法改进:可加一个循环将读入的进程按到达时间从先至后排列。经验体会:通过这次实验,又熟悉了链表的使用方法,加深了对进程概念的理解,进一步掌握了进程状态的转变、进程调度的策略及对系统性能的评价方法。
QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
if(!p) exit(OVERFLOW);
p->data=e;p->next=NULL;
Q.rear->next=p;
Q.rear=p;
return OK;
}
int DeQueue(LinkQueue &Q,QElemType 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 e;
}
bool QueueEmpty(LinkQueue &Q){
(4)测试数据,包括正确的输入及其输出结果和含有错误的输入及其输出结果。
作业
时间片
进程名
A
B
C
D
E
平均
到达时间
0
1
2
3
4
服务时间
4
3
5
2
4
2
完成时间
8
13

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

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

【实验内容】问题描述:设计程序模拟进程的时间片轮转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)输出:要求输出计算出来的每个进程的周转时间,带权周转时间,所有进程的平均周转时间,带权平均周转时间。

实现提示:用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, … ,T n,S1, … ,S n;时间片大小q;按照时间片轮转RR算法进行进程调度,计算进程的完成时间、周转时间和带权周转时间;计算所有进程的平均周转时间和平均带权周转时间;按格式输出调度结果。

实验要求:1)上机前认真复习时间片轮转RR进程调度调度算法,熟悉进程调度的执行过程;2)上机时独立编程、调试程序;3)根据具体实验要求,完成好实验报告(包括实验的目的、内容、要求、源程序、实例运行结果截图)。

【源程序】头文件RR.h#include<iostream>#include<stdio.h>#include<string.h>#include<stdlib.h>#include<ctype.h>#define MaxNum 100typedef struct pcb //定义进程控制块{char Name[MaxNum]; //进程名int arrivetime; //到达时间int runtime; //运行时间int wholetime; //固定运行时间int FinishTime; //完成时间double WeightTime; //周转时间double WeightWholeTime; //带权周转时间char state; //运行后的状态struct pcb *next;}PCB;//全局变量int N; //实际进程数double SumWT; //周转时间之和double SumWWT; //带权周转时间之和double AverageWT; //平均周转时间double AverageWWT; //平均带权周转时间typedef struct //定义队列,封装头结点,指针分别指向队头和队尾{PCB *front,*rear;}queue;queue *init() //进程队列置空{queue *head;head=(queue*)malloc(sizeof(queue));head->front=NULL;head->rear=NULL;return head;}int empty(queue *head) //检验队列是否为空{return (head->front?0:1);}queue *append(queue *head,char c[MaxNum],int a,int r,char s) //进程队列入队,往后插入{PCB *p;p=(PCB *)malloc(sizeof(PCB));strcpy(p->Name,c);p->arrivetime=a;p->runtime=r;p->wholetime=r;p->state=s;//p->FinishTime=0;//p->WeightTime=0;//p->WeightWholeTime=0;p->next=NULL;if(empty(head))head->front=head->rear=p;else{head->rear->next=p;head->rear=p;}return head;}queue *creat(queue *head) //创建进程队列{char c[MaxNum];char s='R';int a,r,i;printf("请输入共有几个进程:\n");scanf("%d",&N);for(i=1;i<=N;i++){printf("请输入第%d 个进程的进程名:\n",i);getchar();gets(c);printf("请输入第%d 个进程的到达时间:\n",i);scanf("%d",&a);printf("请输入第%d 个进程的服务时间:\n",i);scanf("%d",&r);head=append(head,c,a,r,s);}return head;}void print(queue *head) //输入创建的进程队列{PCB *p;p=head->front;if(!p)printf("时间片轮转调度队列为空!\n");while(p){printf("Name=%s arrivetime=%d runtime=%d state=%c",p->Name,p->arrivetime,p->runtime,p->state);printf("\n");p=p->next;}}/*******************时间片轮转法调度算法的实现**************************/void RR(queue *head,int q){int t=head->front->arrivetime, lt=head->rear->arrivetime;if(head->front->runtime<q)t=t+head->front->runtime;elset=t+q;/****进程队列为不空才可调度*****/while(!empty(head)){PCB *p1,*p2;printf("\n时刻进程运行后的状态\n");/*第一种情况:当前运行的时间小于最后一个进程到达时间做一下操作*/while(t<lt){p1=head->front;printf("%2d %s",t,p1->Name);p1->runtime=p1->runtime-q;//1.运行时间小于0,删除队首if(p1->runtime<=0){p1->state='C';printf(" %c\n",p1->state);p1->FinishTime=t;p1->WeightTime=p1->FinishTime-p1->arrivetime;p1->WeightWholeTime=p1->WeightTime/p1->wholetime;SumWT+=p1->WeightTime;SumWWT+=p1->WeightWholeTime;printf("时刻%2d进程%s运行结束,进程%s周转时间=%5.2f,带权周转时间=%5.2f\n",t,p1->Name,p1->Name,p1->WeightTime,p1->WeightWholeTime);head->front=p1->next;free(p1);}//2.运行时间大于0,向后找位置插入else{printf(" %c\n",p1->state);p2=p1->next;while(p2->next && p2->arrivetime != t){p2=p2->next;}//此时无新进入队列的进程,有两种情况:1.不用找位置往后插入,队首不变,不做操作//2.找位置往后插入if(p2->arrivetime != t){PCB *p3=p1,*p4;while(p3->next && p3->arrivetime<t){p4=p3;p3=p3->next;}if(p3->arrivetime>t){if(p4!=p1) //p1插在p4后,头为p1->next{head->front=p1->next;p1->next=p4->next;p4->next=p1;}else //不做操作p4=p3=p2=NULL;}elsep4=p3=p2=NULL;}//此时有新进入队列的进程时:p1插在新进入队列的进程p2后,队首为p1->nextelse{head->front=p1->next;p1->next=p2->next;p2->next=p1;}}//时刻变化if(head->front->runtime<q)t=t+head->front->runtime;elset=t+q;}/*************第一种情况结束**************//******************第二种情况:当期运行的时间大于最后一个进程到达的时间做以下操作*********************/while(t>=lt){p1=head->front;printf("%2d %s",t,p1->Name);p1->runtime=p1->runtime-q;//1.运行时间小于0,删除队首if(p1->runtime<=0){p1->state='C';printf(" %c\n",p1->state);p1->FinishTime=t;p1->WeightTime=p1->FinishTime-p1->arrivetime;p1->WeightWholeTime=p1->WeightTime/p1->wholetime;SumWT+=p1->WeightTime;SumWWT+=p1->WeightWholeTime;printf("时刻%2d进程%s运行结束,进程%s周转时间=%5.2f,带权周转时间=%5.2f\n",t,p1->Name,p1->Name,p1->WeightTime,p1->WeightWholeTime);//printf("时刻%2d进程%s运行结束",t,p1->pname);head->front=p1->next;free(p1);}//2.运行时间大于0,直接插在队尾else{printf(" %c\n",p1->state);//若原队列只有一个进程,不必往队尾插if(!p1->next)head->front=p1;//若原队列有多个进程else{head->front=p1->next;head->rear->next=p1;head->rear=p1;p1->next=NULL;}}//时刻变化,队列为空时不做时刻变化if(empty(head))return;else{if(head->front->runtime<q)t=t+head->front->runtime;elset=t+q;}}/*******第二种情况结束*********/}}//主程序Main.cpp#include<iostream>#include<stdio.h>#include<string.h>#include<stdlib.h>#include<ctype.h>void main(){queue *head;int q;head=init();head=creat(head);printf("\n您输入的时间片轮转进程队列为:\n");print(head);printf("\n请输入时间片轮转调度的时间片为:");scanf("%d",&q);//时间片轮转调度RR(head,q);AverageWT=SumWT/N;AverageWWT=SumWWT/N;printf("平均周转时间=%5.2f,平均带权周转时间=%5.2f",AverageWT,AverageWWT); }【实例运行结果截图】Q=2Q=4。

相关文档
最新文档