操作系统编程：进程管理（优先级）

//process.h

// C++下，模拟进程调度，只考虑优先级和内层资源占用
// 清翔兔 05/10/21 第三次修改

#include <iostream>
using namespace std;
const int eve_priority = 3; //优先级减少数/次
const int eve_time = 5; //CPU运行时间片/次
const int memMax = 100; //内存空间

// 进程类
class process_item {
public:
process_item (int id, int mem, int time, int priority);
bool _ok; // 是否已经完成
bool _on; // 是否已经进入内层
int _mem; // 需要内层空间
int id () {return _id; }
int priority () {return _priority; }
int mem () {return _mem; }
void over () { _ok=1;} //表示进程结束
bool ontime() {return _on;} //检查是否在内层中
//void init_priority () { _priority = 0;}
void init_time () { _time = 0;} //结束时，将时间归0
int time () {return _time; }
//一个时间片后，优先级减少
int down_priority () { _priority -= eve_priority; return _priority;}
//一个时间片后，时间减少
int down_time() {_time -= eve_time; return _time;}
process_item * next() {return _next;}
void next ( process_item *p ) { _next = p;}
void print_item ();
private:
int _id;
//int _mood;
int _time;
int _priority;
process_item * _next;
};

//进程项目类
class process {
public:
process():_front(0),_end(0),_num(0),_memNow(0) {} //进程初始化
int num() { return _num; }
int memNow() { return _memNow; }
void up_num () { _num++; }
void add (int id, int mem, int time, int priority);
int up_memNow (process_item* item);
int down_memNow (process_item* item);
bool in_mem (process_item* item); //进入内存控制
void print();
void done(); //进程主函数
process_item *whichone(); //选择执行进程
process_item *front() { return _front;}
private:
process_item *_front ,*_end;
int _num;
int _memNow; //当前已经被占用的内存空间
};

inline int process::up_memNow( process_item* item ) //进入内存后，增加内存
{
//cout << item->_on << endl; //测试语句
if (item->_on==0)
{
//cout << item->_mem << " " << _memNow ; //测试语句
_memNow +=item->_mem;
item->_on =1;
}
return _memNow;
}

inline int process::down_memNow(process_item* item) //完成后，离开内层
{
_memNow -= item->_mem;
item->_on =0;
return _memNow;
}

bool process::in_mem(process_item* item) //测试能否进入内存，可以就进入
{
if ( item->_ok==1 ) return 0;
if ( item->_on==1 ) return 1;
int t;
t= memNow() + item->_mem;
//cout << item->_mem <<" t: " << t ;
if ( t > memMax) return 0;
else
{
up_memNow (item);
return 1;
}
}

inline process_item::
process_item(int id, int mem, int time, int priority)
:_id(id),_mem(mem),_time(time),_priority(priority),_next(0),_on(0),_ok(0){}

void process_item::print_item ()
{
cout << "id:" << _id
<< "/t priority:" << _priority
<< "/t lefttime:" << _time
<< "/t mem:" << _mem;
}

inline process_item *process::whichone() //选择
{
process_item *m = _front;
while (!in_mem(m) )
{
if (!m->next()) return m;
m=m->next();

}
process_item *p = m->next();
while ( p!=NULL )
{
if ( in_mem(p) //是否进了内层？
&& p->priority() > m->priority() ) m=p;
p = p->next();
}
//up_memNow (m);
return m;
}

inline void process::add (int id, int mem, int time, int priority)
{
process_item *p=
new process_item (id, mem, time, priority);
if ( !_end)
_front = _end = p;
else {
_end->next(p);
_end = p;
}
up_num();
}

void process::print ()
{
process_item *p = _front;
while ( p!=NULL )
{
p->print_item();
p = p->next();
}
cout << "Num:" << _num << endl;
}

void process::done()
{
int tot_time=0;
process_item *m = whichone();
while ( m->time() > 0 )
{
/*
// 如下考虑优先级不为0
if ( m->priority() > eve_time)
m->down_priority();
else
m->init_priority();
*/
m->down_priority(); //降低优先级
if ( m->time() > eve_time) //检查时间满足
{
tot_time += eve_time;
m->down_time();
}
else //对不满足时间的，进行完，并离开内存
{
tot_time += m->time();
down_memNow( m );
m->init_time();
m->over();
}
m->print_item();
cout << "/t/tmemNow:" << memNow() << endl;
m = whichone();
}
}

//main.h

#include "process.h"

void main ()
{
process mytask;
//int id, int mem, int time, int priority
mytask.add(1,13,10,3);
mytask.add(2,91,25,7);
mytask.add(3,27,15,5);
mytask.done();
}