多级反馈队列调度算法的实现

合集下载

多级反馈队列_实验_操作系统

多级反馈队列_实验_操作系统

实验名称:多级反馈队列调度09091201丁奎荣一、实验目的:1、综合应用下列知识点设计并实现操作系统的进程调度,进程状态转换,多组级反馈队列进程调度算法。

2、加深理解操作系统进程调度的过程。

3、加深理解多级反馈队列进程调度算法。

二、实验内容:1、采用一种熟悉的语言,编制程序,最好采用C/C++,界面设计可采用其它自己喜欢的语言。

2、采用多级反馈队列进程调度算法进行进程调度。

3、每个进程对应一个PCB。

在PCB中包括进程标识符pid、进程的状态标志status、进程优先级priority、进程的队列指针next和表示进程生命周期的数据项life(在实际系统中不包括该项)。

4、创建进程时即创建一个PCB,各个进程的pid都是唯一的,pid时在1到100范围的一个整数。

可以创建一个下标为1到100的布尔数组,“真”表示下标对应的进程号是空闲的,“假”表示下标对应的进程号已分配给某个进程。

5、进程状态status的取值为“就绪ready”或“运行run”,刚创建时,状态为“ready”。

被进程调度程序选中后变为“run”。

6、进程优先级priority是0到49范围内的一个随机整数。

7、生命周期life是1到5范围内的一个随机整数。

8、初始化时,创建一个邻接表,包含50各就绪队列,各就绪队列的进程优先级priority分别是0到49。

9、为了模拟用户动态提交任务的过程,要求动态创建进程。

进入进程调度循环后,每次按ctrl+f即动态创建一个过程,然后将该PCB插入就绪队列中。

按ctrl+q 退出进程调度循环。

10、在进程调度循环中,每次选择优先级最大的就绪进程来执行。

将其状态从就绪变为运行,通过延时一段时间来模拟该进程执行一个时间片的过程,然后优先级减半,生命周期减一。

设计图形用户界面GUI,在窗口中显示该进程和其他所有进程的PCB内容。

如果将该运行进程的生命周期不为0,则重新把它变为就绪状态,插入就绪对列中;否则该进程执行完成,撤销其PCB。

多级反馈队列调度算法的原理 -回复

多级反馈队列调度算法的原理 -回复

多级反馈队列调度算法的原理-回复什么是多级反馈队列调度算法?多级反馈队列调度算法是一种进程调度算法,根据进程的优先级和执行时间,将进程分配到不同的处理队列中,并进行轮转执行。

该算法采用了多个队列和反馈机制,使得进程能够相对公平地竞争CPU资源,并且具有较高的响应速度和吞吐量。

多级反馈队列调度算法的原理是什么?多级反馈队列调度算法的原理主要包括以下几个方面:1. 多个队列:多级反馈队列调度算法采用多个队列来存放进程。

一般来说,队列的数量不固定,可以根据实际情况进行调整。

每个队列都有一个不同的优先级,每个优先级代表了不同的执行时间片长度。

2. 进程分配:当一个进程被提交到系统中时,多级反馈队列调度算法会首先将它分配到最高优先级的队列中。

如果该进程在一个时间片内无法完成,那么它就会被移到下一级队列中,并且等待下一次执行。

同样的,进程在下一级队列中也无法完成时,就会被移到更低优先级的队列中。

这个过程会一直持续到该进程执行完成或被终止。

3. 时间片分配:每个队列中的进程都按照其优先级分配时间片。

优先级较高的队列拥有短的时间片,优先级较低的队列拥有长的时间片。

这个机制可以保证高优先级的进程更快地获得CPU资源,从而提高系统的响应速度。

4. 反馈机制:多级反馈队列调度算法还采用了反馈机制,即当进程在一个队列中等待了一定时间之后,它会被移到一个更高优先级的队列中。

这个机制可以有效地解决进程长时间处于低优先级队列中的问题,从而提高处理效率和响应速度。

多级反馈队列调度算法的实现步骤是什么?多级反馈队列调度算法的实现步骤包括以下几个方面:1. 初始化:初始化多个队列,每个队列都有一个不同的优先级,同时初始化时间片大小和进程调度参数。

2. 进程分配:当一个进程被提交到系统中时,将其分配到最高优先级的队列中。

3. 时间片分配:按照优先级分配时间片,优先级较高的队列拥有较短的时间片,优先级较低的队列拥有较长的时间片。

4. 进程执行:从最高优先级的队列中取出一个进程执行,在一个时间片内完成或被抢占后,将进程移到下一级队列中等待执行。

操作系统中的CPU调度算法实现与优化

操作系统中的CPU调度算法实现与优化

操作系统中的CPU调度算法实现与优化随着计算机技术的不断发展,操作系统作为计算机的重要组成部分已经成为了现代计算机的核心,操作系统的性能对整个计算机的运行和效率有着至关重要的影响。

其中,CPU调度算法是操作系统中的核心内容之一,其对操作系统的性能有着直接的影响作用。

什么是CPU调度算法?CPU调度是操作系统中的一项关键任务,主要负责分配CPU 时间片给各个进程,以实现多进程并发执行。

而CPU调度算法则是CPU调度的关键之一,其主要作用是决定进程在什么情况下能够获取CPU使用权,进程的优先级、时间片大小等等影响着操作系统的性能。

常见的CPU调度算法:1. 先来先服务调度算法(FCFS)先来先服务调度算法,即按照作业到达的先后顺序分配CPU 时间片,每个进程在进入就绪队列后,按照行到达时间先后依次排队等待调度,先到达的进程先分配CPU时间片,然后完成执行后才分配给后续的进程。

这种算法不需要任何额外的参数,其实现简单,但是当进程短任务和长任务交织时,会导致短任务长时间等待,并且也不能满足响应时间的需求。

2. 短作业优先调度算法(SJF)短作业优先调度算法,即根据进程的需要任务量分配CPU时间片,等待时间短的任务优先获取CPU使用权,使得短任务能够更快的得到执行,提高系统的响应速度。

但是,该定调度算法仅适用于批处理系统,当进程数量庞大时,无法快速准确地预估进程的任务量,如果预估不准,就会出现长任务等待短任务的情况。

3. 优先级调度算法优先级调度算法是基于进程的优先级确定分配CPU时间片的方法,一般根据进程的特性,为不同进程设置不同的优先级,每次调度时以优先级高的进程优先获取CPU使用权,直到时间片用完或者进程执行结束。

优先级调度算法有着良好的响应性,但不利于低优先级进程,经常会出现饥饿的情况。

4. 时间片轮转调度算法时间片轮转调度算法指将CPU时间片分成一定长度的时间段,按照进程到达的先后依次分配时间片,等待不同进程请求时间的到达,一旦时间到达,则进行轮换,并将未利用完的时间片赋予下一个进程。

调度的调度算法实验报告

调度的调度算法实验报告

调度的调度算法实验报告调度的调度算法实验报告引言:调度是计算机科学中一个重要的概念,它涉及到任务分配、资源管理和优化等方面。

调度算法则是实现调度的关键,它决定了任务的执行顺序和资源的分配方式。

在本次实验中,我们将探讨几种常见的调度算法,并通过实验对其性能进行评估和比较。

一、先来先服务算法(FCFS)先来先服务算法是最简单的调度算法之一,它按照任务到达的先后顺序进行处理。

实验中,我们模拟了一个任务队列,每个任务有不同的执行时间。

通过实验结果可以看出,FCFS算法的优点是简单易懂,但当任务的执行时间差异较大时,会导致平均等待时间较长。

二、最短作业优先算法(SJF)最短作业优先算法是一种非抢占式调度算法,它根据任务的执行时间来进行排序。

实验中,我们将任务按照执行时间从短到长进行排序,并进行调度。

实验结果显示,SJF算法的优点是能够最大程度地减少平均等待时间,但当任务的执行时间无法预测时,该算法可能会导致长任务等待时间过长的问题。

三、时间片轮转算法(RR)时间片轮转算法是一种抢占式调度算法,它将任务分为多个时间片,并按照顺序进行调度。

实验中,我们设置了每个时间片的长度,并将任务按照到达顺序进行调度。

实验结果表明,RR算法的优点是能够公平地分配资源,但当任务的执行时间超过一个时间片时,会导致上下文切换频繁,影响系统的性能。

四、最高响应比优先算法(HRRN)最高响应比优先算法是一种动态调度算法,它根据任务的等待时间和执行时间来计算响应比,并选择响应比最高的任务进行调度。

实验中,我们根据任务的到达时间、执行时间和等待时间计算响应比,并进行调度。

实验结果显示,HRRN算法能够在一定程度上平衡长任务和短任务的等待时间,但当任务的执行时间过长时,会导致其他任务的等待时间过长。

五、多级反馈队列算法(MFQ)多级反馈队列算法是一种综合性的调度算法,它将任务分为多个队列,并根据任务的执行情况进行调度。

实验中,我们设置了多个队列,并根据任务的执行时间和等待时间进行调度。

多级反馈队列调度算法的原理

多级反馈队列调度算法的原理

多级反馈队列调度算法的原理1.多级反馈队列调度算法是一种常见的进程调度算法,旨在平衡系统的吞吐量、响应时间和公平性。

它采用多个队列,每个队列有不同的优先级,进程根据其行为在这些队列之间移动。

本文将详细介绍多级反馈队列调度算法的原理和工作方式。

2. 算法概述多级反馈队列调度算法的核心思想是通过不同优先级的队列来对进程进行调度。

每个队列有不同的时间片大小,高优先级队列的时间片较小,低优先级队列的时间片较大。

当一个进程在当前队列中运行完时间片,它将被移动到下一优先级的队列。

如果一个进程在某个队列运行完时间片后还没有执行完,它将继续在当前队列等待,以便有更多的机会执行。

3. 多级队列结构典型的多级反馈队列调度算法包括多个队列,通常包括三个或更多级别。

每个队列的优先级不同,如高、中、低。

时间片大小逐渐增大,高优先级队列的时间片小于中优先级,中优先级小于低优先级。

4. 调度过程4.1 进程到达当一个新进程到达系统时,它被分配到最高优先级队列。

4.2 运行和时间片耗尽进程在当前队列中运行,如果它的时间片耗尽,它将被移动到下一优先级的队列。

如果进程在当前队列没有完成执行,它将在下一次调度时继续运行。

4.3 优先级提升如果一个进程在低优先级队列等待了很长时间,系统可能会将其提升到高优先级队列,以确保长时间等待的进程有机会获得更多的CPU 时间。

5. 优点5.1 响应时间短由于高优先级队列的时间片较小,进程在高优先级队列中能够更快地执行,因此系统的响应时间相对较短。

5.2 吞吐量高对于短时间运行的进程,能够快速地在高优先级队列中完成执行,有助于提高系统的吞吐量。

5.3 公平性低优先级队列的时间片较大,长时间运行的进程有足够的机会在低优先级队列中执行,增加了系统的公平性。

6. 缺点6.1 管理复杂性多级反馈队列调度算法需要维护多个队列,涉及到队列的调度和进程的迁移,因此管理和实现相对复杂。

6.2 死锁可能如果系统中的进程都是长时间运行的,并且高优先级队列的时间片较小,可能导致低优先级队列中的进程长时间等待,进而引发死锁问题。

立即抢占的多级反馈队列调度算法

立即抢占的多级反馈队列调度算法

立即抢占的多级反馈队列调度算法
多级反馈队列调度算法是一种抢占式的调度算法,它将进程划分为多个队列,并为每个队列分配一个时间片大小。

不同队列的时间片大小逐级递减。

具体的多级反馈队列调度算法包括以下步骤:
1. 初始化:为每个队列设置一个时间片大小,通常情况下,较高级别的队列分配较短的时间片。

2. 将所有进程按照优先级或到达时间加入到第一级别队列中。

3. 从当前队列中选取一个进程执行。

4. 如果该进程运行完,结束并从队列中移除。

5. 如果该进程没有运行完,但时间片已经耗尽,则将该进程移到下一个级别的队列中。

6. 重复步骤3-5,直到所有进程执行完毕。

在多级反馈队列调度算法中,较高级别的队列优先级较高,所以当有高优先级的进程到达时,会抢占正在执行的低优先级进程,确保高优先级进程能够尽快得到执行。

同时,低优先级进程也能够得到执行的机会,不至于被一直阻塞。

通过多级反馈队列调度算法,能够实现较短的响应时间和较高的系统吞吐量,能够更好地满足不同进程的执行需求。

多级反馈队列调度算法

多级反馈队列调度算法

多级反馈队列调度算法:(FB算法)(1)设置多个不同优先级的就绪队列,并赋予各个队列大小不同时间片,使得优先级愈高的队列时间片愈小。

(2)新就绪进程总是先进入第一级(即最高优先级)队列的末尾,并按FIFO原则等待调度;当轮到该进程执行时,如它能在规定时间片内完成,便可准备撤离系统,否则将它转入第二级队列末尾,再同样按FIFO原则等待调度;如果它在第二级队列上运行一个时间片后仍未完成,再依次将它转入第三极队列。

如此下去,当一个长作业从第一级队列降到最后一级队列时,便在该队列中采取时间片轮转方式运行。

(3)系统总是调度第一级队列上的进程执行;仅当第一级队列为空时,才调度第二级队列上的进程执行‘类推之,仅当第1~(i-1)为空时,才调度第i级队列上的进程执行。

多级反馈队列算法可有很多变形,如当处理机正在为第I级队列上的进程服务时,又有新进程进入优先级最高的队列,此时,既可采用立即抢占的方式,将正在执行的进程插入第i级队列的末尾,并将处理机分配给新进程;也可以只按时间片进行抢占,等正在执行的进程时间片用完或它不需要CPU时再进行CPU调度。

例题如下:进程到达和需服务时间进程到达时间服务时间A 0 3B 2 6C 4 4D 6 5E 8 2RR算法中,就绪进程按FIFO方式排列,CPU总是分配给队首的进程,并只能执行一个时间片;FB算法将就绪进程排成多个不同优先权及时间片的队列,就绪进程总是按FIFO方式先进入优先权最高的队列,CPU也总是分配给较高优先权队列上的队首进程,若执行一个时间片仍未完成,则转入下一级队列的末尾,最后一级队列采用时间片轮转方式进行调度。

5101520A B ED C A B ED C A B ED C 05101520RR (q=1)FB (q=2i-1)FB (q=2i-1)立即抢占说明:q=2i-1,其中的i表示是在哪个级的队列上,所以,优先级愈高的队列时间片愈小(原理)(1)q=21-1=1执行A,然后放入到第二级队列末尾(2)q=22-1=2A执行结束此时B已经在2秒时到达,放在第一队列的末尾。

多级反馈队列调度算法_C语言

多级反馈队列调度算法_C语言

多级反馈队列调度算法C语言模拟实现多级反馈队列调度算法:1、设置多个就绪队列,并给队列赋予不同的优先级数,第一个最高,依次递减。

2、赋予各个队列中进程执行时间片的大小,优先级越高的队列,时间片越小。

3、当一个新进程进入内存后,首先将其放入一个对列末尾,如果在一个时间片结束时尚未完成,将其转入第二队列末尾。

4、当一个进程从一个对列移至第n个队列后,便在第n个队列中采用时间片轮转执行完。

5、仅当时间片空闲时,才调度第二个队列中的进程。

(1~i-1)空闲时,才调度i,如果处理机正在第i队列中运行,又有新进程进入优先权较高队列,则新进程抢占处理机,将正在运行的进程放入第i队列队尾,将处理机分给新进程。

#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct node /*进程节点信息*/{char name[20]; /*进程的名字*/int prio; /*进程的优先级*/int round; /*分配CPU的时间片*/int cputime; /*CPU执行时间*/int needtime; /*进程执行所需要的时间*/char state; /*进程的状态,W——就绪态,R——执行态,F——完成态*/int count; /*记录执行的次数*/struct node *next; /*链表指针*/}PCB;typedef struct Queue /*多级就绪队列节点信息*/{PCB *LinkPCB; /*就绪队列中的进程队列指针*/int prio; /*本就绪队列的优先级*/int round; /*本就绪队列所分配的时间片*/struct Queue *next; /*指向下一个就绪队列的链表指针*/}ReadyQueue;PCB *run=NULL,*finish=NULL; /*定义三个队列,就绪队列,执行队列和完成队列*/ReadyQueue *Head = NULL; /*定义第一个就绪队列*/int num; /*进程个数*/int ReadyNum; /*就绪队列个数*/void Output(); /*进程信息输出函数*/void InsertFinish(PCB *in); /*将进程插入到完成队列尾部*/void InsertPrio(ReadyQueue *in); /*创建就绪队列,规定优先数越小,优先级越低*/ void PrioCreate(); /*创建就绪队列输入函数*/void GetFirst(ReadyQueue *queue); /*取得某一个就绪队列中的队头进程*/void InsertLast(PCB *in,ReadyQueue *queue); /*将进程插入到就绪队列尾部*/void ProcessCreate(); /*进程创建函数*/void RoundRun(ReadyQueue *timechip); /*时间片轮转调度算法*/void MultiDispatch(); /*多级调度算法,每次执行一个时间片*/int main(void){PrioCreate(); /*创建就绪队列*/ProcessCreate();/*创建就绪进程队列*/MultiDispatch();/*算法开始*/Output(); /*输出最终的调度序列*/return 0;}void Output() /*进程信息输出函数*/{ReadyQueue *print = Head;PCB *p;printf("进程名\t优先级\t轮数\tcpu时间\t需要时间\t进程状态\t计数器\n");while(print){if(print ->LinkPCB != NULL){p=print ->LinkPCB;while(p){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}}print = print->next;}p = finish;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}p = run;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}}void InsertFinish(PCB *in) /*将进程插入到完成队列尾部*/{PCB *fst;fst = finish;if(finish == NULL){in->next = finish;finish = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void InsertPrio(ReadyQueue *in) /*创建就绪队列,规定优先数越小,优先级越低*/{ReadyQueue *fst,*nxt;fst = nxt = Head;if(Head == NULL) /*如果没有队列,则为第一个元素*/{in->next = Head;Head = in;}else /*查到合适的位置进行插入*/{if(in ->prio >= fst ->prio) /*比第一个还要大,则插入到队头*/{in->next = Head;Head = in;}else{while(fst->next != NULL) /*移动指针查找第一个别它小的元素的位置进行插入*/{nxt = fst;fst = fst->next;}if(fst ->next == NULL) /*已经搜索到队尾,则其优先级数最小,将其插入到队尾即可*/{in ->next = fst ->next;fst ->next = in;}else /*插入到队列中*/{nxt = in;in ->next = fst;}}}}void PrioCreate() /*创建就绪队列输入函数*/{ReadyQueue *tmp;int i;printf("输入就绪队列的个数:\n");scanf("%d",&ReadyNum);printf("输入每个就绪队列的CPU时间片:\n");for(i = 0;i < ReadyNum; i++){if((tmp = (ReadyQueue *)malloc(sizeof(ReadyQueue)))==NULL){perror("malloc");exit(1);}scanf("%d",&(tmp->round)); /*输入此就绪队列中给每个进程所分配的CPU时间片*/tmp ->prio = 50 - tmp->round; /*设置其优先级,时间片越高,其优先级越低*/tmp ->LinkPCB = NULL; /*初始化其连接的进程队列为空*/tmp ->next = NULL;InsertPrio(tmp); /*按照优先级从高到低,建立多个就绪队列*/}}void GetFirst(ReadyQueue *queue) /*取得某一个就绪队列中的队头进程*/{run = queue ->LinkPCB;if(queue ->LinkPCB != NULL){run ->state = 'R';queue ->LinkPCB = queue ->LinkPCB ->next;run ->next = NULL;}}void InsertLast(PCB *in,ReadyQueue *queue) /*将进程插入到就绪队列尾部*/{PCB *fst;fst = queue->LinkPCB;if( queue->LinkPCB == NULL){in->next = queue->LinkPCB;queue->LinkPCB = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void ProcessCreate() /*进程创建函数*/{PCB *tmp;int i;printf("输入进程的个数:\n");scanf("%d",&num);printf("输入进程名字和进程所需时间:\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar(); /*吸收回车符号*/scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->prio = 50 - tmp->needtime; /*设置其优先级,需要的时间越多,优先级越低*/tmp ->round = Head ->round;tmp ->count = 0;InsertLast(tmp,Head); /*按照优先级从高到低,插入到就绪队列*/ }}void RoundRun(ReadyQueue *timechip) /*时间片轮转调度算法*/{int flag = 1;GetFirst(timechip);while(run != NULL){while(flag){run->count++;run->cputime++;run->needtime--;if(run->needtime == 0) /*进程执行完毕*/{run ->state = 'F';InsertFinish(run);flag = 0;}else if(run->count == timechip ->round)/*时间片用完*/{run->state = 'W';run->count = 0; /*计数器清零,为下次做准备*/InsertLast(run,timechip);flag = 0;}}flag = 1;GetFirst(timechip);}}void MultiDispatch() /*多级调度算法,每次执行一个时间片*/{int flag = 1;int k = 0;ReadyQueue *point;point = Head;GetFirst(point);while(run != NULL){Output();if(Head ->LinkPCB!=NULL)point = Head;while(flag){run->count++;run->cputime++;run->needtime--;if(run->needtime == 0) /*进程执行完毕*/{run ->state = 'F';InsertFinish(run);flag = 0;}else if(run->count == run->round)/*时间片用完*/{run->state = 'W';run->count = 0; /*计数器清零,为下次做准备*/if(point ->next!=NULL){run ->round = point->next ->round;/*设置其时间片是下一个就绪队列的时间片*/InsertLast(run,point->next); /*将进程插入到下一个就绪队列中*/flag = 0;}else{RoundRun(point); /*如果为最后一个就绪队列就调用时间片轮转算法*/break;}}++k;if(k == 3){ProcessCreate();}}flag = 1;if(point ->LinkPCB == NULL)/*就绪队列指针下移*/point =point->next;if(point ->next ==NULL){RoundRun(point);break;}GetFirst(point);}}。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
{
return ==NULL;
}
void ClearQueue(LinkQueue& HQ)
{
LNode* p=;
while(p!=NULL) {
=>next;
delete p;
p=;
}
=NULL;
}
void function(LinkQueue* x, int timing)//任务运行
{
int leatime[4];//时间片的大小
if(t->runtime==1&&timing>=t->arrivetime)
t->retime=timing - t->arrivetime;
if(t->runtime == t->burst)
{
t->leavetime=timing+1;
t->roundtime =t->leavetime - t->arrivetime;
if ==NULL)
=NULL;
delete p;
return temp;
}
ElemType *PeekQueue(LinkQueue& HQ)
{
if ==NULL) {cerr<<"队列为空无首元素。"<<endl;exit(1);}
return &>data;
}
bool EmptyQueue(LinkQueue& HQ)
:队列的各个基本功能函数,任务的创建函数与运行函数。
3 详细设计
存储结构描述
struct Job {
int jobnum;obnum>>jobing[i].arrivetime>>jobing[i].burst;
i=0;
while(i!=n||!(EmptyQueue(x[1])&&EmptyQueue(x[2])
void create(LinkQueue* x,Job job)
函数功能:创建任务。
void function(LinkQueue* x, int timing)
函数功能:任务运行。
输入输出
输入:任务号 到达时间 运行时间
输出:任务号 响应时间 离开时间 周转时间、
文件介绍
:主函数的存放,功能函数的调用。
4、对于同一个队列中的有完成任务,就被降到下一个低优先级队列中。
5、在低优先级的队列中的任务在运行时,又有新到达的任务,CPU马上分配给新到达的任务。(注:与原来的题目不同,原题是在低优先级的队列中的任务在运行时,又有新到达的任务时,要在运行完这个时间片后,CPU马上分配给新到达的任务,而本题不需要在运行完这个时间片,即正在进行的任务立刻停止,CPU马上分配给新到达的任务)
cout<<"任务号:"<<t->jobnum<<" "<<"响应时间:"<<t->retime<<" ";
cout<<"离开时间:"<<t->leavetime<<" "<<"周转时间:"<<t->roundtime;
cout<<endl;//输出信息
OutQueue(x[i]);
}
else if((t->runtime == leatime[i]) && (i<=3))
6、为方便实现,时间以1为单位,用整数数据表示;且每个时间点,最多只有一个任务请求服务(即输入)。
2总体设计
算法总体思路:
这是建立在一个时间轴上的,即时刻,一个一个时刻(时间点)进行。
2.1.1主函数思路:
先初始化所有队列,再输入任务个数,如果输入个数为0,则重新输入,然后输入各个任务的信息,即任务号、到达时间、运行时间,再当时刻到任务的到达时间时,就创建任务,然后运行任务,时刻自动加1,创建任务与运行任务进行循环,直到所有任务进行完或所有队列为空才跳出循环,最后清空所有队列。
【关键词】队列优先级任务时间
1 内容与要求
【内容】
多级反馈队列调度算法是操作系统中CPU处理机调度算法之一,该算法既能使高优先级的进程(任务)得到响应又能使短进程(任务)迅速完成。UNIX操作系统便采取这种算法,本次试验就是试用C语言模拟某多级反馈队列调度算法,通过输入任务号、到达时间、运行时间,求出任务完成的先后顺序以及各个任务的响应时间、离开时间、周转时间。
功能模块介绍:
void main ()
函数功能:主函数
void InitQueue(LinkQueue& HQ):队列的初始化
void EnQueue(LinkQueue& HQ,ElemType item)
函数功能:向队列中插入一个元素
ElemType OutQueue(LinkQueue& HQ)
2.1.2功能函数思路:
void create(LinkQueue* x,Job job):使任务的已运行时间为0,再使任务进入第一个队列。
void function(LinkQueue* x, int timing):四个队列从第一个到第四个,即从最高优先级开始,任务在4个队列中逐个进行,根据任务是否为第一次执行,求出响应时间,任务完成时,求出离开时间和周转时间输出信息,在前3个队列,如果任务刚完成一个就绪队列的时间片,就降低优先级,使任务进入下一个队列。
函数功能:从队列中删除一个元素
ElemType *PeekQueue(LinkQueue& HQ)
函数功能:读取队首元素
bool EmptyQueue(LinkQueue& HQ)
函数功能:检查队列是否为空
void ClearQueue(LinkQueue& HQ)
函数功能:清除链队中的所有元素,使之变为空队
{//调整优先级
EnQueue(x[i+1],OutQueue(x[i]));
}
break;
}
i++;
}
}
void create(LinkQueue* x,Job job)
{
=0;
EnQueue(x[1],job);
}
【要求】
多级反馈队列调度算法描述:
1、该调度算法设置四级就绪队列:前三级就绪队列采用时间片轮转法,时间片大小分别为2、4和8;最后一级就绪队列采用FIFO调度。
2、任务在进入待调度的队列等待时,首先进入优先级最高的队列等待。
3、首先调度优先级高的队列中的任务。若高优先级中队列中已没有调度的任务,则调度次优先级队列中的任务,依次类推。
&& EmptyQueue(x[3])&& EmptyQueue(x[4]))){
while(timing==jobing[i].arrivetime)
{
create(x,jobing[i]);<<endl;
exit(1);
}
ElemType temp=>data;
LNode* p=;
=p->next;
学生实习报告
课程名称_数据结构与数据处理应用训练
题目名称多级反馈队列调度算法的实现
学生学院计算机与计算科学
专业班级
学 号
学生姓名
指导教师
2012年 2月16日
多级反馈队列调度算法的实现
【摘要】
多级反馈队列调度算法是操作系统中CPU处理机调度算法之一,该算法既能使高优先级的进程(任务)得到响应又能使短进程(任务)迅速完成。UNIX操作系统便采取这种算法,而本次试验就是试用C语言模拟某多级反馈队列调度算法。本次试验中前三级就绪队列采用时间片轮转法,时间片大小分别为2、4和8,最后一级就绪队列采用FIFO调度,将任务进入多级队列进行模拟,任务从优先级高的队列到优先级地的队列的顺序逐一进入,还用了算法支持抢占式,最后完成模拟,得到各个任务先后完成的顺序,还有得到各个任务的响应时间、离开时间、周转时间。
leatime[0]=0;
leatime[1]=2;
leatime[2]=6;
leatime[3]=14;
Job *t=NULL;
int i=1;
while(i<5)
{
if(EmptyQueue(x[i])==false)//如果队列不为空
{
t=PeekQueue(x[i]);//读取队首元素
t->runtime++;//已运行时间+1
相关文档
最新文档