【操作系統】多級反饋隊列算法

1. 原理介紹

1. RR時間片輪轉原理

  　　　　在采用時間片輪轉算法中，所有的就緒進程按FCFS策略排成一個就緒隊列。系統可設置每隔一定時間便產生一次中斷，去激活進程調度程序進行調度，把CPU分配給隊首進程，並令其執行一個時間片。當它運行完畢后，又把處理機分配給就緒隊列中新的隊首進程，也讓它執行一個時間片。這樣，就可以保證就緒隊列中的所有進程在確定的時間段內，都能獲得一個時間片的處理機時間。

　　　　在RR調度算法中進程的切換，可分為兩種情況:①若一個時間片尚未用完，正在運行的進程便已經完成，就立即激活調度程序，將它從就緒隊列中刪除，再調度就緒隊列中隊首的進程運行，並啟動一個新的時間片。②在一個時間片用完時，計時器中斷處理程序被激活。如果進程尚未運行完畢，調度程序將把它送往就緒隊列的末尾。

　　　

　　2.多級反饋隊列調度機制

　　　　設置多個就緒隊列。在系統中設置多個就緒隊列，並為每個隊列賦予不同的優先。第一個隊列的優先級最高，第二個次之，其余隊列的優先級逐個降低。該算法為不同列中的進程所賦予的執行時間片的大小也各不相同，在優先級愈高的隊列中，其時間片愈小。

　　　　每個隊列都采用FCFS算法。當新進程進入內存后，首先將它放入第一隊列的末尾，按FCFS原則等待調度。當輪到該進程執行時，如它能在該時間片內完成，便可撤離系統。否則，即它在一個時間片結束時尚未完成，調度程序將其轉入第二隊列的末尾等待調度;如果它在第二隊列中運行個時間片后仍未完成， 再依次將它放入第三隊列...依此類推。當進程最后被降到第n隊列后，在第n隊列中便采取按RR方式運行。

　　　　按隊列優先級調度。調度程序首先調度最高優先級隊列中的諸進程運行，僅當第一隊列空閑時才調度第二隊列中的進程運行;僅當第1到(i-1)所有隊列均空時，才會調度第i隊列中的進程運行。如果處理機正在第i隊列中為某進程服務時又有新進程進入任一優先級較高的隊列，此時須立即把正在運行的進程放回到第i隊列的末尾，而把處理機分配給新到的高優先級進程。

　　

　　　　2.設計原理

　　　　PCB設計

　　　　設計結構體PCB，其中包括進程的標識符，到達時間，服務時間，完成時間，周轉時間和帶權周轉時間。利用動態數組將所有進程存儲起來。

　　　　

struct PCB

{

int ID; //標識符

int ComeTime; //到達時間

int ServerTime; //服務時間

int FinishTime; //完成時間

int TurnoverTime; //周轉時間

double WeightedTurnoverTime; //帶權周轉時間

};

 

 

　　進程就緒隊列

　　采用STL中的隊列設置3個隊列，queue<PCB> Ready[3];

　　時間片由數組timeslice[3]表示，大小分別為2，4,8。

 

　　函數模塊

　　主函數模塊分為3個模塊:讀入數據函數，多級反饋調度函數，輸出函數。

　　

　　3.流程圖

         

 

 

　　　　4.代碼實現

#include <iostream>
#include <algorithm>
#include <iomanip>
#include <vector>
#include <queue>
using namespace std;
 
//作業結構體
typedef struct PCB
{
    int ID;                            //標識符
    int ComeTime;                    //到達時間
    int ServerTime;                    //服務時間
    int FinishTime;                    //完成時間
    int TurnoverTime;                //周轉時間
    double WeightedTurnoverTime;    //帶權周轉時間
}PCB;
const int QueueNum = 3;//就緒隊列長度     
int timeslice[QueueNum];//第一個時間片 


 
//輸入作業信息
void InputPCB(vector<PCB> &PCBList, int xlice[])
{
    
    cout << "輸入3個時間片大小: "<<endl;
    for(int i=0;i<3;i++){
        cin >> timeslice[i];
    } 
    
    while(1) {
        PCB temp;
        cout << "輸入標識符   "<<"到達時間    "<<"服務時間 "<<endl;
        cin >> temp.ID>> temp.ComeTime>> temp.ServerTime;
        temp.FinishTime = 0;        //暫時存放運行了多少時間，來判斷此作業是否運行結束
        PCBList.push_back(temp);
         cout<<"繼續？Y/N："<<endl;
        char n;
        cin>>n;
        if(n=='Y'||n=='y')
        continue;
        else 
        break; 
        
    }
}
 
 
 bool CmpByComeTime(const PCB &p1, const PCB &p2)
{
    return p1.ComeTime < p2.ComeTime;
}

 
//MFQ算法
void MFQ(vector<PCB> &PCBList, int timeslice[])
{
    sort(PCBList.begin(), PCBList.end(), CmpByComeTime);        //按到達時間排序
    vector<PCB> result;    //保存結果
    int BeginTime = (*PCBList.begin()).ComeTime;                    //第一個作業開始時間
    queue<PCB> Ready[QueueNum];        //設置3個就緒隊列
    Ready[0].push(*PCBList.begin());
    PCBList.erase(PCBList.begin());
    cout<<"當前時刻:"<<BeginTime<<"   當前就緒隊列:"<<0<<endl;
    cout<<"第一個進程進入就緒隊列0"<<endl;
    cout<<endl;                
    while (!PCBList.empty())//進程數組不空 
    {
            //這段是為了防止前面的進程運行完了，后面的進程還沒到，造成死循環
        bool flag = false;
        for (int i = 0; i < QueueNum; ++i)
        {
            if (!Ready[i].empty())
            {
                flag = true;
                break;
            }
        }
        if(!flag)
        {
            Ready[0].push(*PCBList.begin());
            PCBList.erase(PCBList.begin());
            BeginTime = Ready[0].front().ComeTime;
        }
 
        for (int i = 0; i < QueueNum; ++i)
        { 
        
            if (i != QueueNum - 1)        //不是最后一個隊列
            {
                while (!Ready[i].empty())    //當前隊列不空
                {
                    if (!PCBList.empty() && BeginTime>= (*PCBList.begin()).ComeTime)    //有新作業到達，加入就緒隊列，轉到第一隊列
                    {
                        cout<<"當前時刻:"<<BeginTime<<endl;
                        cout<<"新進程"<<(*PCBList.begin()).ID<<"到達，將其放在第一隊列尾部"<<endl;
                        cout<<endl;     
                        Ready[0].push(*PCBList.begin());
                        PCBList.erase(PCBList.begin());
                        i = 0; 
                        
                        continue;
                    }
 
                    if (Ready[i].front().FinishTime + timeslice[i] < Ready[i].front().ServerTime)        //時間片用完沒運行完,加入下一隊列隊尾
                    {
                        cout<<"當前時刻:"<<BeginTime+ timeslice[i]<<"   當前就緒隊列:"<<i<<endl;
                        cout<<"當前進程"<<Ready[i].front().ID<<"在時間片內沒有運行完，加入下一個隊列尾部！"<<endl; 
                        cout<<endl;    
                        
                        Ready[i].front().FinishTime += timeslice[i] ;
                        Ready[i + 1].push(Ready[i].front());//加入下一個隊列 
                        Ready[i].pop();
                        BeginTime +=  timeslice[i] ;
                    }
                    else        //此作業運行完
                    {   
                        BeginTime += Ready[i].front().ServerTime - Ready[i].front().FinishTime;
                        Ready[i].front().FinishTime = BeginTime;
                        Ready[i].front().TurnoverTime = Ready[i].front().FinishTime - Ready[i].front().ComeTime;
                        Ready[i].front().WeightedTurnoverTime = (double)Ready[i].front().TurnoverTime / Ready[i].front().ServerTime;
                         cout<<"當前時刻:"<<BeginTime<<"   當前就緒隊列:"<<i<<endl;
                         cout<<"當前進程"<<    Ready[i].front().ID<<"在時間片內運行完！"<<endl;
                         cout<<endl;    
                        //從就緒隊列中移除作業
                        result.push_back(Ready[i].front());
                        Ready[i].pop();
                    }
                }
            }
            else
            {
                while (!Ready[i].empty())
                {
                    if (!PCBList.empty() && BeginTime >= (*PCBList.begin()).ComeTime)    //有新作業到達，加入就緒隊列，轉到第一隊列
                    {
                        cout<<"當前時刻:"<<BeginTime<<endl;
                        cout<<"新進程"<<(*PCBList.begin()).ID<<"到達，將其放在最后隊列尾部"<<endl; 
                        cout<<endl;    
                        Ready[0].push(*PCBList.begin());
                        PCBList.erase(PCBList.begin());
                        i = -1;
                        break;
                    }
                    if (Ready[i].front().FinishTime + timeslice[i]  < Ready[i].front().ServerTime)        //時間片用完沒運行完,加入隊尾
                    {   cout<<"當前時刻:"<<BeginTime+ timeslice[i]<<"   當前就緒隊列:"<<i<<endl;
                        cout<<"當前進程"<<Ready[i].front().ID<<"在時間片內沒有運行完，加入該隊列尾部！"<<endl; 
                        cout<<endl;    
                        Ready[i].front().FinishTime += timeslice[i] ;
                        Ready[i].push(Ready[i].front());
                        Ready[i].pop();
                        BeginTime +=  timeslice[i] ;
                    }
                    else        //此作業運行完
                    {
                        BeginTime += Ready[i].front().ServerTime - Ready[i].front().FinishTime;
                        Ready[i].front().FinishTime = BeginTime;
                        Ready[i].front().TurnoverTime = Ready[i].front().FinishTime - Ready[i].front().ComeTime;
                        Ready[i].front().WeightedTurnoverTime = (double)Ready[i].front().TurnoverTime / Ready[i].front().ServerTime;
                         cout<<"當前時刻:"<<BeginTime<<"   當前就緒隊列:"<<i<<endl;
                        cout<<"當前進程"<<    Ready[i].front().ID<<"在時間片內運行完！"<<endl;
                        cout<<endl;    
                        //從就緒隊列中移除作業
                        result.push_back(Ready[i].front());
                        Ready[i].pop();
                    }
                }
            }
        }
    }
 
    //按ComeTime升序排序，便於顯示結果
    PCBList = result;
    sort(PCBList.begin(), PCBList.end(), CmpByComeTime);
}
 
//顯示結果
void show(vector<PCB> &PCBList)
{
    int SumTurnoverTime = 0;
    double SumWeightedTurnoverTime = 0;
 
    cout<<"標識符     "<<"達到時間    "<<"服務時間    "<<"完成時間    "<<"周轉時間    "<<"帶權周轉時間" <<endl;
    
    for (vector<PCB>::iterator it = PCBList.begin(); it < PCBList.end(); ++it){
        cout<<(*it).ID<<"          "<<(*it).ComeTime<<"            "<< (*it).ServerTime<<"            "<<(*it).FinishTime<<"            "<<(*it).TurnoverTime<<"           "<< (*it).WeightedTurnoverTime<<endl;
        SumTurnoverTime+=(*it).TurnoverTime;
        SumWeightedTurnoverTime+=(*it).WeightedTurnoverTime;
    }
    
    cout << "平均周轉時間: " << (double)SumTurnoverTime / PCBList.size() << endl;
    cout << "平均帶權周轉時間: " << SumWeightedTurnoverTime / PCBList.size() << endl;
}
 
//比較函數，按ComeTime升序排列


 
int main()
{
    vector<PCB> PCBList;//動態數組存放進程 

    InputPCB(PCBList, timeslice);//輸入時間片大小，作業信息
 
    MFQ(PCBList, timeslice);
 
    show(PCBList);//顯示結果
 
    return 0;
}
 

　　　　

　　　　　　5.實例測試

 

 

 

結果分析：

如圖5所示，0時刻，1進程到達，運行1個時間片2，此時進程沒有運行完，加入下一隊列，進程2到達，轉到隊列0調度進程2，運行1個時間片2，進入隊列1隊尾等待。

時刻4開始，第一隊列為空，此時調度第二隊列，在進程1運行1個時間片4，沒有運行完，加入隊列2。

時刻8，進程3到達，加入到第一隊列尾部，調度進程3，進程3運行1個時間片2之后，加入下一隊列。

時刻10，隊列1中進程2開始運行，時刻12運行結束。刪除進程2.進程3開始運行，當前時間片內運行不完，加到隊列2隊尾。

時刻16，進入隊列2，調度進程1進行運行，時刻20，進程1運行結束，刪除進程1。運行進程3，在當前時間片下不能運行完，則加入隊列2。

時刻28，進入隊列2，調度進程3，時刻29運行完畢。