精华内容
下载资源
问答
  • 多级反馈队列调度算法可以如下原理: 1、设有N个队列(Q1,Q2…QN),其中各个队列对于处理机的优先级是不一样的,也就是说位于各个队列的作业(进程)的优先级也是不一样的。一般来说,优先级Priority(Q1) > ...

    多级队列调度算法

    • 多级队列:该算法将系统中的进程就绪队列从一个拆分为若干个,将不同类型或性质的进程固定分配在不同的就绪队列,不同的就绪队列采用不同的调度算法,一个就绪队列中的进程可以设置不同的优先级,不同的就绪队列本身也可以设置不同的优先级。
      多级队列调度算法由于设置多个就绪队列,因此对每个就绪队列就可以实施不同的调度算法,因此,系统针对不同用户进程的需求,很容易提供多种调度策略。

    题目描述:

    • 设RQ分为RQ1和RQ2
    • RQ1采用轮转法,时间片q=7.
    • RQ1>RQ2
    • RQ2采用短进程优先调度算法。
    • 测试数据如下:
    • 其中:RQ1: P1-P5,   RQ2: P6-P10 
      
    进程 P1 P2 P3 P4 P5 P6 P7 P8 P9 P10
    运行时间 16 11 14 13 15 21 18 10 7 14
    已等待时间 6 5 4 3 2 1 2 3 4 5

    程序功能

    • 对于给定的数据使用多级队列调度算法进行分析计算周转时间。其中多级队列分为RQ1和RQ2 ,RQ1采用的是时间片长度为7的时间片轮转算法,RQ2采用的是短进程优先算法。并且RQ1的优先级高于RQ2(即只有在RQ1内所有程序运行结束,RQ2才能开始运行)

    设计思路

    • 时间片轮转:首先对RQ1按照等待时间长短排序,然后从头设置循环,只要队列不空就一直进行下去,每次取队头RQ1的下一个元素(RQ1仅用作标志,不存储数据)判断need是否小于等于时间片大小,小于等于则置为0后踢出队列进入finish队列,大于则将need减去时间片大小,然后将其移动至队尾。
    • 短进程优先:开始前需要对RQ2按照剩余执行时间大小进行排序,与时间片轮转法类似,不同的是这里一旦开始执行就直接执行完毕,然后下一个进程上处理机运行。
      在这里插入图片描述

    数据结构

    • 本程序每个进程用一个PCB表示,每个PCB内含有name(标识符)、need(当前仍然需要多长时间才能运行结束)、turn(周转时间(等于等待时间+运行时间))、next指针(指向等待队列的下一个进程)。两个队列的头节点分别为RQ1、RQ2还有一个结束队列Finish(运行结束后进程从原队列进入这里)
    typedef struct tag_pcb {
        char name[8];
        int need = 0;//需要运行的时间
        int turn = 0;//周转时间=等待时间+运行时间
        struct tag_pcb* next = NULL;
    }PCB;
    PCB* RQ1=new PCB, * RQ2 = new PCB, * Finish = new PCB;
    

    代码实现:

    #include<iostream>
    #include <fstream>
    using namespace std;
    
    
    typedef struct tag_pcb {
        char name[8];
        int need = 0;//需要运行的时间
        int turn = 0;//周转时间=等待时间+运行时间
        struct tag_pcb* next = NULL;
    }PCB;
    PCB* RQ1=new PCB, * RQ2 = new PCB, * Finish = new PCB;
    const int TimePiece = 7;//时间片长度
    
    void ReadFile(){
    
        ifstream In("RQ1.txt");
        PCB* Current = RQ1;
    
        while (!In.eof()) {
            PCB* Cur = new PCB;
    
            In >> Cur->name >> Cur->need>> Cur->turn;
    
            Current->next = Cur;
            Current = Current->next;
        }
        In.close();
    
        ifstream In1("RQ2.txt");
        PCB* Current1 = RQ2;
    
        while (!In1.eof()) {
            PCB* Cur1 = new PCB;
    
            In1 >> Cur1->name >> Cur1->need >> Cur1->turn;
            Current1->next = Cur1;
            Current1 = Current1->next;
        }
        In1.close();
    }
    
    void Q1_Insert(PCB a) { //时间片轮转算法队列的插入(插入尾部)
    
        PCB* Current = RQ1;
        while (Current->next != NULL)
            Current = Current->next;
        Current->next = new PCB;
    
        *Current->next = a;
        //Current->next = &a;
    
        Current->next->next = NULL;
    
    }
    void Q2_Insert(PCB b) { //短进程优先调度算法队列的插入
    
        
        PCB* Current = RQ2;
        while (Current->next != NULL)
            Current = Current->next;
        Current->next = new PCB;
    
        *Current->next = b;
        Current->next->next = NULL;
        
    }
    void Fin_Insert(PCB c) { //短进程优先调度算法队列的插入
        
        PCB* cc = new PCB;
        *cc = c;
    
        cc->next = Finish->next;
        Finish->next = cc;   
    }
    void Q2_sort(PCB *T) {
    
        PCB* X = new PCB;//用来保存排序后的链表
        PCB* p = new PCB;//用来保存当此最小值的前一位
        PCB* Current = T->next;
        PCB * PreCurrent = T;
        PCB* TailX = X;
        
        while (T->next != NULL) {
            int tem = 999999;
    
            Current = T->next;
            PreCurrent = T;
            while (Current != NULL) {
                if (Current->need < tem) {
                    tem = Current->need;
                    
                    p = PreCurrent;
                    //cout << "处理" << p->name << p->need << "\n";
                }
                Current = Current->next;
                PreCurrent = PreCurrent->next;
            }
         
    
            TailX->next = p->next;
            TailX = TailX->next;
    
            if (p->next->next != NULL)
                p->next = p->next->next;
            else
                p->next = NULL;      
        }
        *T = *X;
    }
    
    int main()
    {
        ReadFile();
    
        int clock = 0; //时钟
        while (RQ1->next != NULL) {//表示RQ1还有元素
            int t = TimePiece;
            PCB* Current = RQ1->next;
            int fin = 0;
    
            if (Current->need <= t)
                t = Current->need, fin = 1;
               
            clock += t;//表示pi运行t
    
            //输出计算过程
            //cout << "\n" << Current->name << "_____" << Current->turn << "__+ ___" << clock << "__= ___" << Current->turn +clock << "\n";
           
            Current->need -= t;
      
            if (fin)
                Current->turn += clock, Fin_Insert(*Current);//运行结束    
            else
                Q1_Insert(*Current);//进入队尾等待运行
    
            if (Current->next == NULL)
                break;
            RQ1->next = Current->next;
        }
    
    
        clock = 0;//时钟要清空一次
        Q2_sort(RQ2);//先排序
    
        cout << "RQ2:__"; 
        for (PCB* Current2 = RQ2->next; Current2 != NULL; Current2 = Current2->next)
            cout << Current2->name << "--";
    
        while (RQ2->next != NULL) {//表示RQ2还有元素(到这一步默认RQ1已经为空)
            PCB* Current3 = RQ2->next;
            int t = Current3->need;
    
            clock += t;//表示pi运行t
            Current3->need -= t;//实质为清空
            Current3->turn += clock;
    
            Fin_Insert(*Current3);
    
            if (Current3->next == NULL)
                break;
            RQ2->next = Current3->next;
        }
    
        int SUM = 0;
        for (PCB* Current2 = Finish->next; Current2 != NULL; Current2 = Current2->next) {
            cout << "\n" << Current2->name <<"\t"<< Current2->turn ;
            SUM += Current2->turn;
        }
    
        cout << "\n总周转时间为:" << SUM << "\n";
    }
    
    
    • 多级队列调度测试结果:
      在这里插入图片描述

    附:

    多级反馈队列调度算法如下原理:

    • 1、设有N个队列(Q1,Q2…QN),其中各个队列对于处理机的优先级是不一样的,也就是说位于各个队列中的作业(进程)的优先级也是不一样的。一般来说,优先级Priority(Q1) > Priority(Q2) > … > Priority(QN)。怎么讲,位于Q1中的任何一个作业(进程)都要比Q2中的任何一个作业(进程)相对于CPU的优先级要高(也就是说,Q1中的作业一定要比Q2中的作业先被处理机调度),依次类推其它的队列。
    • 2、对于优先级最低的队列来说,里面是遵循时间片轮转法。也就是说,位于队列QN中有M个作业,它们的运行时间是通过QN这个队列所设定的时间片来确定的;对于其他队列,遵循的是先来先服务算法,每一进程分配一定的时间片,若时间片运行完时进程未结束,则进入下一优先级队列的末尾。
    • 3、各个队列的时间片是一样的吗?
      不一样,这就是该算法设计的精妙之处。各个队列的时间片是随着优先级的增加而减少的,也就是说,优先级越高的队列中它的时间片就越短。同时,为了便于那些超大作业的完成,最后一个队列QN(优先级最低的队列)的时间片一般很大(不需要考虑这个问题)。

    上述程序在某一进程在一级队列运行一轮后没有运行完毕,若加入二级队列而不是加入原队列的尾部,则可以实现简单的多级反馈队列调度算法
    两种算法的不同之处就在于:当一个RQ1中的进程在时间片结束之后是回到当前的队尾还是到RQ2队列之中。
    在上述程序中也很容易实现:

    		if (fin)
                Current->turn += clock, Fin_Insert(*Current);//运行结束    
            else
                Q1_Insert(*Current);//进入队尾等待运行
    

    修改为:

    		if (fin)
                Fin_Insert(*Current);//运行结束    
            else
                Q2_Insert(*Current);//进入二级队列等待运行
            Current->turn += clock, 
    

    上述两种代码分别实现了上述两种功能,执行时只需选一种在相应位置即可。

    • 多级反馈队列调度测试结果:在这里插入图片描述

    由分析上述数据容易发现:在该测试数据的情况下多级反馈队列调度算法是要优于多级队列调度的

    展开全文
  • 多级(假设为N级)反馈队列调度算法可以如下原理1、设有N个队列(Q1,Q2….QN),其中各个队列对于处理机的优先级是不一样的,也就是说位于各个队列的作业(进程)的优先级也是不一样的。一般来说,优先级Priority(Q1) ...

    多级反馈队列调度算法是一种CPU处理机调度算法,UNIX操作系统采取的便是这种调度算法。

    多级(假设为N级)反馈队列调度算法可以如下原理

    1、设有N个队列(Q1,Q2….QN),其中各个队列对于处理机的优先级是不一样的,也就是说位于各个队列中的作业(进程)的优先级也是不一样的。一般来说,优先级Priority(Q1) > Priority(Q2) > … > Priority(QN)。怎么讲,位于Q1中的任何一个作业(进程)都要比Q2中的任何一个作业(进程)相对于CPU的优先级要高(也就是说,Q1中的作业一定要比Q2中的作业先被处理机调度),依次类推其它的队列。

    2、对于某个特定的队列来说,里面是遵循时间片轮转法。也就是说,位于队列Q2中有N个作业,它们的运行时间是通过Q2这个队列所设定的时间片来确定的(为了便于理解,我们也可以认为特定队列中的作业的优先级是按照FCFS来调度的)。

    3、各个队列的时间片是一样的吗?不一样,这就是该算法设计的精妙之处。各个队列的时间片是随着优先级的增加而减少的,也就是说,优先级越高的队列中它的时间片就越短。同时,为了便于那些超大作业的完成,最后一个队列QN(优先级最低的队列)的时间片一般很大(不需要考虑这个问题)。

    多级反馈队列调度算法描述
    1、进程在进入待调度的队列等待时,首先进入优先级最高的Q1等待。

    2、首先调度优先级高的队列中的进程。若高优先级中队列中已没有调度的进程,则调度次优先级队列中的进程。例如:Q1,Q2,Q3三个队列,只有在Q1中没有进程等待时才去调度Q2,同理,只有Q1,Q2都为空时才会去调度Q3。

    3、对于同一个队列中的各个进程,按照时间片轮转法调度。比如Q1队列的时间片为N,那么Q1中的作业在经历了N个时间片后若还没有完成,则进入Q2队列等待,若Q2的时间片用完后作业还不能完成,一直进入下一级队列,直至完成。

    4、在低优先级的队列中的进程在运行时,又有新到达的作业,那么在运行完这个时间片后,CPU马上分配给新到达的作业(抢占式)。

    我们来看一下该算法是如何运作的
    假设系统中有3个反馈队列Q1,Q2,Q3,时间片分别为2,4,8。
    现在有3个作业J1,J2,J3分别在时间 0 ,1,3时刻到达。而它们所需要的CPU时间分别是3,2,1个时间片。

    1、时刻0 J1到达。于是进入到队列1 , 运行1个时间片 , 时间片还未到,此时J2到达。

    2、时刻1 J2到达。 由于时间片仍然由J1掌控,于是等待。 J1在运行了1个时间片后,已经完成了在Q1中的

    2个时间片的限制,于是J1置于Q2等待被调度。现在处理机分配给J2。

    3、时刻2 J1进入Q2等待调度,J2获得CPU开始运行。

    4、时刻3 J3到达,由于J2的时间片未到,故J3在Q1等待调度,J1也在Q2等待调度。

    5、时刻4 J2处理完成,由于J3,J1都在等待调度,但是J3所在的队列比J1所在的队列的优先级要高,于是J3被调度,J1继续在Q2等待。

    6、时刻5 J3经过1个时间片,完成。

    7、时刻6 由于Q1已经空闲,于是开始调度Q2中的作业,则J1得到处理器开始运行。 J1再经过一个时间片,完成了任务。于是整个调度过程结束。

    从上面的例子看,在多级反馈队列中,后进的作业不一定慢完成。

    展开全文
  • 多级反馈队列调度算法

    千次阅读 2020-04-10 22:31:44
    多级反馈队列调度算法是目前操作系统调度算法被公认的一种较好的调度算法。它可以满足各种类型进程的需要,既能使高优先级的作业得到响应又能使短作业(进程)迅速完成。 基本概念 多级反馈队列调度算法是一种...

    多级反馈队列调度算法

     

    多级反馈队列调度算法.png

    如果有很多任务排队等着被处理,哪个任务先被处理,哪个任务后处理,这个需要由操作系统决定,这就是调度。多级反馈队列调度算法是目前操作系统调度算法中被公认的一种较好的调度算法。它可以满足各种类型进程的需要,既能使高优先级的作业得到响应又能使短作业(进程)迅速完成。

    基本概念

    多级反馈队列调度算法是一种根据先来先服务原则给就绪队列排序,为就绪队列赋予不同的优先级数,不同的时间片,按照优先级抢占CPU的调度算法。算法的实施过程如下:

    1. 按照先来先服务原则排序,设置N个就绪队列为Q1,Q2...QN,每个队列中都可以放很多作业;
    2. 为这N个就绪队列赋予不同的优先级,第一个队列的优先级最高,第二个队列次之,其余各队列的优先权逐个降低;
    3. 设置每个就绪队列的时间片,优先权越高,算法赋予队列的时间片越小。时间片大小的设定按照实际作业(进程)的需要调整;
    4. 进程在进入待调度的队列等待时,首先进入优先级最高的Q1等待。
    5. 首先调度优先级高的队列中的进程。若高优先级中队列中已没有调度的进程,则调度次优先级队列中的进程。例如:Q1,Q2,Q3三个队列,只有在Q1中没有进程等待时才去调度Q2,同理,只有Q1,Q2都为空时才会去调度Q3。
    6. 对于同一个队列中的各个进程,按照时间片轮转法调度。比如Q1队列的时间片为N,那么Q1中的作业在经历了时间片为N的时间后,若还没有完成,则进入Q2队列等待,若Q2的时间片用完后作业还不能完成,一直进入下一级队列,直至完成。
    7. 在低优先级的队列中的进程在运行时,又有新到达的作业,那么在运行完这个时间片后,CPU马上分配给新到达的作业即抢占式调度CPU。

    应用范围

    此算法应用于同一个资源的多个使用者可分优先级使用资源的情况。

    使用方法及步骤

    假设系统中有3个就绪队列Q1,Q2,Q3,时间片分别为2,4,8。

    现在有3个作业J1,J2,J3分别在时间 0 ,1,3时刻到达。而它们所需要的CPU时间分别是3,2,1个时间片。

    1、时刻0: J1到达。于是进入到队列1 , 运行1个时间片 , 时间片还未到,此时J2到达。

    2、时刻1: J2到达。 由于时间片仍然由J1掌控,于是等待。 J1在运行了1个时间片后,已经完成了在Q1中的2个时间片的限制,于是J1置于Q2等待被调度。现在处理机分配给J2。

    3、时刻2: J1进入Q2等待调度,J2获得CPU开始运行。

    4、时刻3:J3到达,由于J2的时间片未到,故J3在Q1等待调度,J1也在Q2等待调度。

    5、时刻4:J2处理完成,由于J3,J1都在等待调度,但是J3所在的队列比J1所在的队列的优先级要高,于是J3被调度,J1继续在Q2等待。

    6、时刻5:J3经过1个时间片,完成。

    7、时刻6:由于Q1已经空闲,于是开始调度Q2中的作业,则J1得到处理器开始运行。

    8、时刻7:J1再经过一个时间片,完成了任务。于是整个调度过程结束。

    应用案例

    应用1-男主人处理妻子和母亲的要求

    案例:中国男人在婆媳关系的融洽中起着非常重要的作用。现有一例子,母亲有一件事情A要男人帮忙,1小时后妻子也有一件事情B要男人帮忙,两件事情各自需要的时间为2小时和1小时。假设事情在家里就可以完成,男人在家,母亲叫儿子帮忙后,男人开始做的时间为下午3:00。 男人该怎么样分配做事情的顺序?

    解决步骤:

    1. 根据题目,设定男人连续做事时长分别为半小时和1小时
    2. 下午3:00,按照先来先服务原则,母亲先叫儿子办事情,所以男人先帮母亲做事情A,此时事情A等级为1;
    3. 下午4:00,妻子叫男人帮忙,于是男人暂停事情A(事情A还剩下1个小时的执行过程),开始做事情B,事情B等级为1,此时事情A等级降为2,
    4. 下午4:30,男人暂停事情B,此时事情B等级降为2(事情B还剩下半个小时的执行过程),帮母亲干事情A
    5. 下午5:30,男人完成事情A,帮妻子干事情B
    6. 下午6:00,男人完成事情B

    这个过程中,男人既完了了母亲的任务,也完成了妻子的任务,两件事情交叉处理,没有出现母亲一直等,或是妻子一直等的情况。这就是多任务的一种调度方式。

    可以体现的计算思维

    多级反馈队列调度算法体现了计算思维的调度特点,应用了先来先服务原则、应用时间片等做法使得每个申请者都能及时使用资源,是一种很好的协调整体的解决方案。

    ——摘自计算思维百科

     

    转载自:https://www.cnblogs.com/Roni-i/p/10291822.html

    展开全文
  • 优先级队列调度算法

    千次阅读 2008-10-31 15:58:00
    一、优先级队列调度算法的描述该算法有个队列,同一个队列的进程优先级相同,不同队列进程优先级不同;最高优先级上的进程运行1个时间片,次高优先级上的进程运行2个时间片,再下一级运行4个时间片,...
    
    

     

    一、

    多优先级队列调度算法的描述

    该算法有多个队列,同一个队列中的进程优先级相同,不同队列中进程优先级不同;最高优先级上的进程运行1个时间片,次高优先级上的进程运行2个时间片,再下一级运行4个时间片,依此类推;每次从队列头开始运行进程,每当一个进程在一个优先级队列中用完它的时间片后,就移到队列的尾部;只有当高优先级队列为空时才会从不为空的低优先级队列中选择进程运行;在低优先级队列中等待时间过长的进程,将移入高优先级队列。

    二、多优先级队列数据结构的定义

    多优先级队列数据结构的定义

    进程数据结构的定义

    class MultiPriorityQueueSchedule{

    private:

           MYPROCESS MultiPriorityQueue[QUEUESIZE];

    private:

           void        MPQSFreeProcess(MYPROCESS);

           MYPROCESS MPQSSelectProcess();

           void        MPQSRunProcess(MYPROCESS);

           void        MPQSGoAfter(MYPROCESS);//到队列尾

           void        MPQSPriorityScheduling();//优先级调度

    public:

           MultiPriorityQueueSchedule();

           bool        MPQSAppendProcess(MYPROCESS);

           void        MPQSExecute();

           void        MPQSDisplayQueue(ofstream&);

    };

    typedef struct MyProcess

    {

           char*      MyProcessname;

           int           CreateTime;

           int           LastExecTime;

           int           JobWeight;

           int           EstimateUsedTime;

           int           Priority;

           MyProcess *next;

    }* MYPROCESS;

    其他函数:

    MYPROCESS CreateMyProcess(char* name, int JW, int Prio);  //创建进程

    int EstimateRunTime(int JW);                            //估计进程运行时间

    void BurstTime(int st);                                  //SYSTIME增加

    void PriorityScheduling(MYPROCESS);                   //调整进程优先级

    三、Select方法

    1)  从高优先级队列到低优先级队列,当高优先级队列为空时才进入低优先级队列,否则跳到2)。当所有队列为空时,跳到4)。

    2)  选择此优先级队列的头一个进程运行,进程运行完它的时间片后,把此进程放到此优先级队列的尾部,跳到3)。

    3)  调整所有进程的优先级,跳到1)。

    4)  <?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" />

     

    四、编程测试

    根据上述内容进行编程,运行程序截图如下:

    <?xml:namespace prefix = v ns = "urn:schemas-microsoft-com:vml" />

    1:动态多优先级调度的过程图

     

    2:静态多优先级队列和动态多优先级队列的比较

           附录中展示了程序中的类、函数和一些变量的定义。

     

    附录

    1. /*MultiPriorityQueue.h*/
    2. /*Power by Keamou@CS@CITS@NKU*/
    3. #include <string.h>
    4. #include <math.h>
    5. #define QUEUESIZE 32  //队列大小
    6. #define SLICETIME 5   //时间片
    7. static int SYSTIME = 0;  //假设系统时间
    8. int EstimateRunTime(int JobWeight)
    9. {
    10.     return JobWeight;
    11. }  /*估计进程运行时间*/
    12. typedef struct MyProcess
    13. {
    14.     char*   MyProcessname;
    15.     int     CreateTime;
    16.     int     LastExecTime;
    17.     int     JobWeight;
    18.     int     EstimateUsedTime;
    19.     int     Priority;
    20.     MyProcess *next;
    21. }* MYPROCESS;   /*进程定义*/
    22. MYPROCESS CreateMyProcess(char* name, int JW, int Prio)
    23. {
    24.     MYPROCESS myproc;
    25.     myproc = new MyProcess;
    26.     myproc->MyProcessname = new char [10];
    27.     strcpy(myproc->MyProcessname,name);
    28.     myproc->CreateTime = SYSTIME ;
    29.     myproc->LastExecTime = SYSTIME;
    30.     myproc->JobWeight = JW ;
    31.     myproc->EstimateUsedTime = EstimateRunTime(JW) ;
    32.     myproc->Priority = Prio;
    33.     myproc->next=NULL;
    34.     return myproc;
    35. }  /*创建进程*/
    36. void BurstTime(int st)
    37. {
    38.     SYSTIME += st ;
    39. }  /*改变系统时间*/
    40. void PriorityScheduling(MYPROCESS myproc)
    41. {
    42.     if ((SYSTIME-myproc->LastExecTime) > myproc->EstimateUsedTime)
    43.     {
    44.         myproc->Priority--;
    45.         if (myproc->Priority<0)
    46.         {
    47.             myproc->Priority=0;
    48.         }
    49.     }
    50. }   /*优先级调度*/
    51. class MultiPriorityQueueSchedule
    52. {
    53. private:
    54.     MYPROCESS MultiPriorityQueue[QUEUESIZE];
    55. private:
    56.     void        MPQSFreeProcess(MYPROCESS);
    57.     MYPROCESS   MPQSSelectProcess();
    58.     void        MPQSRunProcess(MYPROCESS);
    59.     void        MPQSGoAfter(MYPROCESS);
    60.     void        MPQSPriorityScheduling();
    61. public:
    62.     MultiPriorityQueueSchedule();
    63.     bool        MPQSAppendProcess(MYPROCESS);
    64.     void        MPQSExecute();
    65.     void        MPQSDisplayQueue(ofstream&);
    66. };   /*多优先级调度队列的定义*/
    67. MultiPriorityQueueSchedule::MultiPriorityQueueSchedule(){
    68.     for(int i=0;i<QUEUESIZE;i++)
    69.     {
    70.         MultiPriorityQueue[i] = NULL;
    71.     }
    72. }   /*构造函数*/
    73. bool MultiPriorityQueueSchedule::MPQSAppendProcess(MYPROCESS myproc)
    74. {
    75.     if (myproc->Priority >= QUEUESIZE)
    76.     {
    77.         return false;
    78.     }
    79.     myproc->next = MultiPriorityQueue[myproc->Priority];
    80.     MultiPriorityQueue[myproc->Priority] = myproc;
    81.     return true;
    82. }   /*在多优先级队列中加入进程*/
    83. void MultiPriorityQueueSchedule::MPQSFreeProcess(MYPROCESS myproc)
    84. {
    85.     MultiPriorityQueue[myproc->Priority] = myproc->next ;
    86.     delete myproc;
    87. }    /*释放进程*/
    88. MYPROCESS MultiPriorityQueueSchedule::MPQSSelectProcess()
    89. {
    90.     int SearchNum ;
    91.     for(SearchNum = 0; SearchNum < QUEUESIZE; SearchNum++ )
    92.     {
    93.         if (MultiPriorityQueue[SearchNum] != NULL)
    94.         {
    95.             return MultiPriorityQueue[SearchNum];
    96.         }
    97.     }
    98.     return NULL;
    99. }   /*选择运行进程*/
    100. void MultiPriorityQueueSchedule::MPQSGoAfter(MYPROCESS myproc)
    101. {
    102.     int QueueNum;
    103.     QueueNum = myproc->Priority ;
    104.     MultiPriorityQueue[QueueNum] = myproc->next;
    105.     MYPROCESS proctemp;
    106.     proctemp= MultiPriorityQueue[QueueNum];
    107.     if (proctemp == NULL)
    108.     {
    109.         MultiPriorityQueue[QueueNum] = myproc;
    110.         return;
    111.     }
    112.     while (proctemp->next != NULL)
    113.     {
    114.         proctemp = proctemp->next ;
    115.     }
    116.     proctemp->next = myproc ;
    117.     myproc->next=NULL;
    118. }   /*将运行后的进程放到队列尾部*/
    119. void MultiPriorityQueueSchedule::MPQSPriorityScheduling()
    120. {
    121.     int PriorityNum ;
    122.     MYPROCESS myproc;
    123.     MYPROCESS proctemp;
    124.     for(PriorityNum = 0; PriorityNum < QUEUESIZE; PriorityNum++ )
    125.     {
    126.         myproc = MultiPriorityQueue[PriorityNum];
    127.         while (myproc!=NULL)
    128.         {
    129.             PriorityScheduling(myproc);
    130.             if (myproc->Priority != PriorityNum)
    131.             {
    132.                 MultiPriorityQueue[PriorityNum]=myproc->next;
    133.                 MPQSAppendProcess(myproc);
    134.                 myproc=MultiPriorityQueue[PriorityNum];
    135.             }
    136.             else
    137.                 break;
    138.         }
    139.         while (myproc!=NULL&&myproc->next!=NULL)
    140.         {
    141.             PriorityScheduling(myproc->next);
    142.             if (myproc->next->Priority!=PriorityNum)
    143.             {
    144.                 proctemp=myproc->next;
    145.                 myproc->next=myproc->next->next;
    146.                 MPQSAppendProcess(proctemp);
    147.             }
    148.             else
    149.                 myproc=myproc->next;
    150.         }
    151.     }
    152. }
    153. void MultiPriorityQueueSchedule::MPQSRunProcess(MYPROCESS myproc)
    154. {
    155.     if(myproc == NULL)
    156.         return;
    157.     int Runtime;
    158.     Runtime = (pow(2,myproc->Priority))*SLICETIME ;
    159.     myproc->EstimateUsedTime -= Runtime;
    160.     if (myproc->EstimateUsedTime <= 0)
    161.     {
    162.         BurstTime(Runtime+myproc->EstimateUsedTime);
    163.         cout<<SYSTIME<<" /t"<<myproc->MyProcessname<<" /t"<<myproc->Priority<<"  /tFree"<<endl;
    164.         MPQSFreeProcess(myproc);
    165.     }
    166.     else
    167.     {
    168.         BurstTime(Runtime);
    169.         cout<<SYSTIME<<" /t"<<myproc->MyProcessname<<" /t"<<myproc->Priority<<"  /tSwitch"<<endl;
    170.         MPQSGoAfter(myproc);
    171.     }
    172. }   /*多优先级队列中的优先级调整调度*/
    173. void MultiPriorityQueueSchedule::MPQSExecute()
    174. {
    175.     MYPROCESS myproc;
    176.     do {
    177.         myproc=MPQSSelectProcess();
    178.         MPQSRunProcess(myproc);
    179.         MPQSPriorityScheduling();
    180.     } while(myproc!=NULL);
    181. }   /*运行进程*/
    182. void MultiPriorityQueueSchedule::MPQSDisplayQueue(ofstream& fout)
    183. {
    184.     int SearchNum ;
    185.     MYPROCESS myproc;
    186.     for(SearchNum = 0; SearchNum < QUEUESIZE; SearchNum++ )
    187.     {
    188.         myproc = MultiPriorityQueue[SearchNum];
    189.         while (myproc != NULL)
    190.         {
    191.             fout<<myproc->MyProcessname<<"  /t"<<myproc->Priority<<"  /t"<<myproc->EstimateUsedTime<<endl;
    192.             myproc = myproc->next ;
    193.         }
    194.     }
    195. }   /*显示多优先级队列的状态*/
    展开全文
  • 容量调度器是YARN提供的三种调度的一种,这种调度器允许个组织(队列)共享一个Hadoop集群,每个组织(队列)所分配的集群资源是固定的且可配置的。每个组织(队列)内部还可以进一步划分成小队列,小队列...
  • 队列调度算法

    千次阅读 2011-07-26 14:26:35
    QoS队列调度算法概述Generalized processor sharing Fair queuing 每个时间片,每个队列得到的时间相同。Weighted fair queuing 每个时间片,每个队列得到的时间,按权重得到不同比例的时间。FIFO
  • 一、多级反馈队列调度算法 多级反馈队列调度算法是进程调度的一种算法,该调度算法可以不用事先知道各种进程所需的执行时间,还可以较好的满足各种类型进程的需要,是目前共认的一种较好的进程调度算法。 那你可能...
  • 多级反馈队列调度算法4.三种算法的对比总结 0.思维导图 1.时间片轮转—RR Round-Robin 时间片为2举例 以时间片为5举例 可能出现的问题,比如与FCFS对比 2.优先级调度算法 非抢占式例子 - 抢占式例子 ...
  • 公平调度器可以为所有的应用“平均公平”分配资源,当然,这种“公平”是可以配置的,称为权重,可以在分配文件中为每一个队列设置分配资源的权重,如果没有设置,默认是1(由于默认权重相同,因此,在不做配置的...
  • QoS队列调度算法概述

    千次阅读 2012-10-23 21:57:27
    QoS队列调度算法概述 作者: | 上传时间:2011-04-22 | 关键字:网络大爬虫4-QoS专题 文/常慧锋 【摘要】本文概述了常用队列调度算法的实现机制,并在此基础上对比了基于理想流模型的WFQ...
  • 时间片轮转调度算法、优先级调度算法、多级反馈队列调度算法 1.先了解下算法的评估 cpu 利用率 = 忙碌时间 / 总时间 系统吞吐量 = 总共完成多少道作业 / 总共花了多少时间 周转时间 周转时间:(作业提交到 操作系统...
  • 操作系统_多级反馈队列调度算法

    千次阅读 2018-12-17 17:38:43
    1、设置 N 个就绪进程队列,即队列 0,队列 1,……,队列 N-1,用于存放就绪进程。每个队列 优先级不同,且从队列 0 到...3、在队列内部,进程之间采用先来先服务(FCFS)算法辅以时间片限时机制进行调度:位于队...
  • QoS和QoS队列调度算法

    千次阅读 2017-10-26 15:15:25
    在QoS队列调度中有如下算法,分别如下:  1、SP  SP:Strict Priority(严格优先级), SP调度严格按照优先级从高到低的次序优先发送较高优先级队列中的分组,当较高优先级队列为空时,再发送较低优先级队列中...
  • QOS队列调度机制简介

    千次阅读 2017-07-26 14:04:17
    1 简介队列调度机制在QoS技术体系属于拥塞管理的范畴。虽然企业和运营商想尽一切办法去扩展自己的链路带宽,但是现实网络上各种应用对带宽的消耗速度远远超出企业和运营商带宽扩充能力,也就是说网络的拥塞是无法...
  • 多级反馈队列调度算法(转)

    千次阅读 2019-01-19 15:18:00
    多级反馈队列调度算法是目前操作系统调度算法被公认的一种较好的调度算法。它可以满足各种类型进程的需要,既能使高优先级的作业得到响应又能使短作业(进程)迅速完成。 基本概念 多级反馈队列调度算法是一种...
  • 五、多级队列调度: 六、多级反馈队列调度: CPU调度算法处理的问题是:从就绪队列选择进程以便为其分配CPU。 一、先到先服务调度: First Come,First Served(FCFS) 定义:先请求CPU的进程首先分配到CPU。...
  • 抢占式优先级调度算法:新进程来的时候判断一下是不是要抢占只有第1级队列所以的运行完了才会把CPU给第2级队列,P2在第二级队列运行到1个时间片后 P3到达第1级队列,此时P2就立马不运行了,重新进入第2级队列排着,...
  • Java模拟CPU的多级反馈队列调度算法

    千次阅读 2019-03-27 21:17:30
    最近在学习过程了解到了关于CPU的调度算法,试着用Java简单模拟了多级反馈队列调度算法(学习阶段,可能存在bug)。 在CPU的调度算法,多级反馈队列算法是一种比较优秀的算法,其能够在快速响应高优先级的进程...
  • 多级反馈队列调度算法(MFQ)

    万次阅读 2015-12-09 00:48:04
    多级反馈队列调度算法是目前公认的较好的一种进程调度算法,它能较好的满足各类进程的需要。 MFQ算法首先设置个就绪队列。队列的优先级递减,且各队列时间片大小也不同。例如我实现的算法里,设置了3个队列,第...
  • 关于多级反馈队列调度算法 首先,这是交互系统采用的调度算法,分别是: 轮转调度RR(Round Robin) 最高优先级调度HPF(Highest Priority First) 多级反馈队列(Multiple feedback queue) 最短进程优先...
  • 操作系统 --多级反馈队列调度算法

    万次阅读 2018-10-30 12:31:03
    在系统设置个就绪队列,并为每个队列赋予不同的优先级,从第一个开始逐个降低。不同队列进程所赋予的执行时间也不同,优先级越高,时间片越小。 (2)每个队列都采用FCFS(先来先服务)算法。轮到该进程执行...
  • C语言实现多级反馈队列调度算法

    万次阅读 2015-08-12 16:05:37
    C语言实现多级反馈队列调度算法 #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct node /*进程节点信息*/ { char name[20]; /*进程的名字*/ int prio; /*进程的优先级*/ int ...
  • 调度队列模型

    千次阅读 2017-02-19 20:37:45
    调度队列模型及准则 1 仅有进程调度调度队列模型: 每个进程在执行时都可能出现以下三种情况: (1) 任务在给定的时间片内已经完成,该进程便在释放处理机后进入完成状态 (2) 任务在本次分得的时间...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 233,388
精华内容 93,355
关键字:

多队列调度方法中