动态优先权的进程调度算法的模拟

实验目的:通过动态优先权算法的模拟加深进程概念和进程调度过程的理解,并学习撰写规范的科学研究报告。
设计思路:
1.对N个进程采用动态优先权算法的进程调度;
2.每个用来标识进程的进程控制块PCB用结构描述,包括以下字段:进程标识数ID,进程优先数PRIORITY,进程以占用的CPU时间CPUTIME,进程还需占用的CPU时间ALLTIME,进程状态STATE等。
3.优先数改变的原则:进程在就绪队列中呆一个时间片,优先数增加1,进程每运行一个时间片优先数减3。
4.设置调度前的初始状态。
5.将每个时间片内的进程情况显示出来。

使用的数据结构 priority_queue
priority_queue 优先级队列是一个拥有权值概念的单项队列queue,所有元素按照优先级排列,可以认为queue是一个按照进入队列的先后做为优先级的优先级队列。priority_queue 优先队列容器,特性为队列中最大的元素总是位于队首。元素比较规则默认为按照元素的从大到小排序。
实现方法:
使用结构体PCB,初始化id, priority, cputime, alltime, state.
创建结构体数组,压入优先队列Q,重载操作符 < 使得队列按照priority的大小排序。 弹出队列队首元素,为优先级最高的进程,设置状态为run,在一个时间片中,该优先级最高的进程优先级减3,同时cputime加1,alltime减1,如果存在alltime=0的进程,则将其的状态属性改为finish,在就绪队列中的进程优先级都加1。 在下一个时间片中,再选择优先级最高的进程运行,重复执行上述过程,直到所有的进程的状态都为finish。 process
源代码:

#include <iostream>
#include <queue>
#include <iomanip>

using namespace std;

#define N 4

enum STATE {ready,run,finish};// 就绪 运行 结束  三种状态
void state_declare(STATE s)
{
    switch (s) {
        case 0:
            cout<<"ready.";
            break;
        case 1:
            cout<<"run.";
            break;
        case 2:
            cout<<"finish";
            break;
        default:
            break;
    }
}

//  插入就绪队列的进程数据
int id_array[N]={0,1,2,3};
int pri_array[N]={14,30,18,1};
int cputime_array[N]={0,0,0,0};
int alltime_array[N]={3,2,3,2};

typedef struct PCB
{
    int id;
    int priority;
    int cputime; // 已占用CPU时间
    int alltime; // 还需占用CPU时间
    STATE state;
    bool operator<(const PCB &o)const
    {
        return priority<o.priority;
    }
    
}pcb;  // 进程控制块 pcb 结构体

pcb p[N];
priority_queue<pcb> Q;  // 优先队列
pcb process_one;
int i,time_slice=0;  // 时间片time_slice

void init()  // 初始化赋值
{
    for(i=0;i<N;i++)
    {
        p[i].id=id_array[i];
        p[i].priority=pri_array[i];
        p[i].cputime=cputime_array[i];
        p[i].alltime=alltime_array[i];
        p[i].state=ready;
        Q.push(p[i]);
    }
}

int main()
{
    init();
    while(1)
    {
        time_slice++;
        cout<<"时间片"<<time_slice<<"结束后:"<<endl;
        
        process_one=Q.top();
        if(process_one.state!=finish)
        {
            Q=priority_queue<pcb>();
            process_one.state=run;
            process_one.priority-=3;
            process_one.cputime++;
            process_one.alltime--;
            cout<<"进程 "<<process_one.id<<"在时间片"<<time_slice<<"运行"<<endl;
            
            if(process_one.alltime<=0)
            {
                process_one.state=finish;
                process_one.priority=-1024;
            }
            for(i=0;i<N;i++)
            {
                if(i!=process_one.id)
                {
                    if(p[i].state!=finish)
                        p[i].priority++;
                    if(p[i].alltime<=0)
                        p[i].state=finish;
                    Q.push(p[i]);
                }
                else
                {
                    p[i].id=process_one.id;
                    p[i].priority=process_one.priority;
                    p[i].cputime=process_one.cputime;
                    p[i].alltime=process_one.alltime;
                    p[i].state=process_one.state;
                    Q.push(p[i]);
                    
                }
            }
            // show the status of all the processes
            cout<<"id  "<<"priority "<<"cputime "<<"alltime "<<"state"<<endl;
            for (i=0;i<N;i++) {
                cout<<p[i].id<<"  "<<setw(5)<<p[i].priority<<"  "<<setw(5)<<
                p[i].cputime<<"  "<<setw(5)<<p[i].alltime<<setw(5)<<"  ";
                state_declare(p[i].state);cout<<endl;
            }
            cout<<endl;
        }
        
        else
        {
            cout<<"No process available."<<endl;
            break;
        }
        
    }
    return 0;
}

运行结果:

时间片1结束后:
进程 1在时间片1运行
id  priority cputime alltime state
0     15      0      3     ready.
1     27      1      1     run.
2     19      0      3     ready.
3      2      0      2     ready.

时间片2结束后:
进程 1在时间片2运行
id  priority cputime alltime state
0     16      0      3     ready.
1  -1024      2      0     finish
2     20      0      3     ready.
3      3      0      2     ready.

时间片3结束后:
进程 2在时间片3运行
id  priority cputime alltime state
0     17      0      3     ready.
1  -1024      2      0     finish
2     17      1      2     run.
3      4      0      2     ready.

时间片4结束后:
进程 0在时间片4运行
id  priority cputime alltime state
0     14      1      2     run.
1  -1024      2      0     finish
2     18      1      2     run.
3      5      0      2     ready.

时间片5结束后:
进程 2在时间片5运行
id  priority cputime alltime state
0     15      1      2     run.
1  -1024      2      0     finish
2     15      2      1     run.
3      6      0      2     ready.

时间片6结束后:
进程 0在时间片6运行
id  priority cputime alltime state
0     12      2      1     run.
1  -1024      2      0     finish
2     16      2      1     run.
3      7      0      2     ready.

时间片7结束后:
进程 2在时间片7运行
id  priority cputime alltime state
0     13      2      1     run.
1  -1024      2      0     finish
2  -1024      3      0     finish
3      8      0      2     ready.

时间片8结束后:
进程 0在时间片8运行
id  priority cputime alltime state
0  -1024      3      0     finish
1  -1024      2      0     finish
2  -1024      3      0     finish
3      9      0      2     ready.

时间片9结束后:
进程 3在时间片9运行
id  priority cputime alltime state
0  -1024      3      0     finish
1  -1024      2      0     finish
2  -1024      3      0     finish
3      6      1      1     run.

时间片10结束后:
进程 3在时间片10运行
id  priority cputime alltime state
0  -1024      3      0     finish
1  -1024      2      0     finish
2  -1024      3      0     finish
3  -1024      2      0     finish

时间片11结束后:
No process available.

不得不承认,参考了师兄的文章 思想是一样的,实现方式有些不同http://blog.sina.com.cn/s/blog_6635898a0102dybg.html
本人主要使用了STL模板中queue的priority_queue

stl priority_queue of C++ with struct
priority_queue 和 结构体struct使用的方法
http://stackoverflow.com/questions/15601973/stl-priority-queue-of-c-with-struct

Here is a slightly modified answer to your original question, which you deleted for no apparent reason. The original contained enough information for you to figure this out, but here it goes: provide a less than comparison that uses the int for comparison.

All you need to do is provide a functor that implements a less-than comparison with strict weak ordering, or a less-than operator for your class implementing the same. This struct satisfies the requirements:

struct thing
{
int a;
char b;
bool operator<(const thing& rhs) const { return a < rhs.a; } }; #include

使用setw(num) 实现数据的间隔与对齐
数据间隔与对齐
c++输入输出 常用设置方法:输出空格符或回车换行符。
c++输入输出 指定数据输出宽度:用C++提供的函数setw()指定输出数据项的宽度。setw()括号中通常给出一个正整数值,用于限定紧跟其后的一个数据项的输出宽度。如:setw(8)表示紧跟其后的数据项的输出占8个字符宽度。
c++输入输出 举例:
int i=2, j=3;
float x=2.6, y=1.8;
cout<
//setiosflags(ios::right) 右对齐 默认
//setiosflags(ios::left) 左对齐

Spread the love