cxshiyan.txt

该程序实现了操作系统的进程调度的功能 采用优先级抢占的算法以及普通的优先级算法

*　进程调度实验
*　本程序提供了以下几种种进程调度方法
*1、可强占优先法
*2、普通的优先级算法
*
*/
#include <iostream.h>
#include <string.h>
#include <fstream.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>

const int TIMESLICE = 1;//时间片
const int FINISH=0;//完成状态
const int RUNNING=1;//运行状态
const int READY=2;//就绪状态
const int IO=3;//io状态
const int WAIT=4;//等待IO
const int PCBNUM=2;//进程个数
typedef struct {
long pid;
char pname[10];
int pstate;
int pneedtime;
int piostarttime;
int pioneedtime;
int ptime;
int priority;
}pcbs;//pcb结构

class pcbnode;
//队列结点
class pcbnode
{
public:
pcbs *pcb;
pcbnode *link;
pcbnode();
~pcbnode();
int run();//运行操作
int runend();//运行结束？
void runio();//IO操作
int ioend();//io结束？
int insertnode(pcbnode *p,pcbnode *q);//在q后插入结点p
int deletenode(pcbnode *p,pcbnode *q);//删除p结点，q为p的前驱
int addnode(pcbnode *p);//增加结点
int pcbnode::isio();//是否开始IO
};

pcbnode::pcbnode()
{
pcb=0;
link=0;
}
pcbnode::~pcbnode()
{
if (link)
delete link;
if (pcb)
pcb->pstate=FINISH;
}
int pcbnode::run()
{
pcb->pstate = RUNNING;
++(pcb->ptime);
pcb->priority --;//优先级降低
return 0;
}
int pcbnode::runend()
{
return (pcb->pneedtime <= pcb->ptime);
}
int pcbnode::isio()
{
return (pcb->piostarttime == pcb->ptime && pcb->pioneedtime>0);
}
int pcbnode::ioend()
{
return ((pcb->pioneedtime) <= 0);
}
void pcbnode::runio()
{
pcb->pstate = IO;
--(pcb->pioneedtime);
}
int pcbnode::addnode(pcbnode *p)
{
pcbnode *q;
q = this;
p->pcb->pstate = READY;
while(q->link){
q=q->link;
}
q->link=p;
return 0;
}
int pcbnode::insertnode(pcbnode *p,pcbnode *q)
{
p->link = q->link;
q->link = p;
return 0;
}
int pcbnode::deletenode(pcbnode *p,pcbnode *q)
{
q->link = p->link;
p->link = 0;
return 0;
}
int randInt( int seed)
//随即函数：产生不大于seed的正整数
{
int r;
r=rand();
while ( r>seed || r<0 )
r=rand();
return r;
}
void newpcb(pcbs *pcb, int order)
//随机生成进程
{
char buf[10];
pcb->pid = order;
strcpy(pcb->pname,"proc");
itoa(order,buf,10);
strcat(pcb->pname,buf);
pcb->pneedtime = randInt(10);
pcb->piostarttime = randInt(pcb->pneedtime);
pcb->pioneedtime = randInt(10);
pcb->ptime = 0;
pcb->priority = randInt(10);
}
void pprint(pcbs *pcb, int count)
{
//打印进程状态
ofstream ofs("result.txt", ios::out|ios::app);
cout<<"id name stat need iostart ioneed runtime pri"<<endl;
ofs<<"id name stat need iostart ioneed runtime pri"<<endl;
for (int i=0;i<count;i++){
cout<<pcb.pid<<\' \'<< pcb.pname<<\' \';
ofs<< pcb.pid<<\' \'<< pcb.pname<<\' \';
tch (pcb.pstate){
case IO:
cout<<"IO";
ofs<<"IO";
break;
case RUNNING:
cout<<"RU ";
ofs<<"RU ";
break;
case READY:
cout<<"RE";
ofs<<"RE";
break;
case FINISH:
cout<<"FI";
ofs<<"FI";
break;
case WAIT:
cout<<"WA";
ofs<<"WA";
break;
}
cout<<\' \'<<pcb.pneedtime;
ofs<<\' \'<<pcb.pneedtime;
cout<<\' \'<<pcb.piostarttime<<\' \'<<pcb.pioneedtime<<\' \'<<pcb.ptime;
ofs<<\' \'<<pcb.piostarttime<<\' \'<<pcb.pioneedtime<<\' \'<<pcb.ptime;
cout<<\' \'<<pcb.priority;
ofs<<\' \'<<pcb.priority;
cout<< endl;
ofs<< endl;
}
ofs<<"---------------------------------------------"<<endl;
cout<<"---------------------------------------------"<<endl;
}
void priority(pcbs * pcb, int pcbsnum)
//可抢占的优先调度
/*
* 从就绪队列中取出最优先的进程送到运行队列
* 每运行一次，正在运行的进程优先数减1，等待的进程优先数加1
* 如果就绪队列中的最大优先数进程的优先数大于正在运行的优先数，
* 则运行的进程让出cpu,排到就绪队列的尾部，将最大优先数的进程送进
* 运行队列。
*/
{
pcbnode running,ready,blocked;
pcbnode *p,*f,*front;
pcbnode *q;
/*将进程表中的进程加到就绪队列中*/
for ( int i=0;i<pcbsnum;i++) {
p = new pcbnode;
p->pcb = pcb+i;
ready.addnode(p);
}
while(ready.link || running.link || blocked.link) {
//判断将运行队列中的进程是否要io或结束
if (running.link) {
if (running.link->isio()) {//需要IO?
blocked.addnode(running.link);
running.link->pcb->pstate = WAIT;
running.link = 0;
}else if (running.link->runend()) {//运行结束?
p = running.link;
running.link = 0;
delete p;
}
}
//寻找最大的一个优先级
p=ready.link;
q=p;
f=&ready;
front = f;
if (p) {
int maxpri = p->pcb->priority;
while(p) {
if (p->pcb->priority > maxpri) {
maxpri = p->pcb->priority;
front = f;
q = p;
}
f = p;
p = p->link;
}
}
//如果最大优先级大于正在运行的优先级则强占cpu
//
p = running.link;
if (q)
if (p) {
if ( p->pcb->priority < q->pcb->priority) {
ready.addnode(p);
running.deletenode(p, &running);
p->pcb->pstate = READY;
running.addnode(q);
ready.deletenode(q, front);
q->pcb->pstate = RUNNING;
}
}
else {
running.addnode(q);
ready.deletenode(q, front);
q->pcb->pstate=RUNNING;
}
/*
* 将处理完IO的进程送到就绪队列
*/
p = blocked.link;
q = &blocked;
if (p) {
int r;
r = p->ioend();
if (r) {
blocked.deletenode(p, q);
ready.addnode(p);
p=q->link;
}
}

/*
* 运行进程
*/
p= running.link;
q = &running;
if(p) {
int r;
if (!(p->isio()))
//is IO start?
r=p->run();//RUN
}
/*
* 进行IO
*/
p= blocked.link;
q= &blocked;
if (p)
p->runio();

//动态计算就绪队列优先级
p = ready.link;
while (p) {
(p->pcb->priority) ++;
p = p->link;
}
//print proc state
pprint(pcb, pcbsnum);
}
}

void generalpriority(pcbs * pcb, int pcbsnum)
//普通的优先调度
/*
* 从就绪队列中取出最优先的进程送到运行队列
* 如果运行结束或要执行IO再重新调度
*/
{
pcbnode running,ready,blocked;
pcbnode *p,*f,*front;
pcbnode *q;
/*将进程表中的进程加到就绪队列中*/
for ( int i=0;i<pcbsnum;i++) {
p = new pcbnode;
p->pcb = pcb+i;
ready.addnode(p);
}
while(ready.link || running.link || blocked.link) {
//判断将运行队列中的进程是否要io或结束
if (running.link) {
if (running.link->isio()) {//需要IO?
blocked.addnode(running.link);
running.link->pcb->pstate = WAIT;
running.link = 0;
}else if (running.link->runend()) {//运行结束?
p = running.link;
running.link = 0;
delete p;
}
}
if (!running.link) {
//当运行队列为空
//寻找最大的一个优先级
p = ready.link;
q = p;
f = &ready;
front = f;
if (p) {
int maxpri = p->pcb->priority;
while(p) {
if (p->pcb->priority > maxpri) {
maxpri = p->pcb->priority;
front = f;
q = p;
}
f = p;
p = p->link;
}
}
p = running.link;
if (q) {
running.addnode(q);
ready.deletenode(q, front);
q->pcb->pstate=RUNNING;
}
}
/*
* 将处理完IO的进程送到就绪队列
*/
p = blocked.link;
q = &blocked;
if (p) {
int r;
r = p->ioend();
if (r) {
blocked.deletenode(p, q);
ready.addnode(p);
p=q->link;
}
}

/*
* 运行进程
*/
p = running.link;
q = &running;
if (p) {
int r;
if (!(p->isio()))
//is IO start?
r=p->run();//RUN
}
/*
* 进行IO
*/
p = blocked.link;
q = &blocked;
if (p)
p->runio();
//print proc state
pprint(pcb, pcbsnum);
}
}
void main()
{
pcbs *pclist;//进程表
remove("result.txt");
pclist = new pcbs[PCBNUM];//为进程表分配空间
for(int i = 0; i < PCBNUM; i++)
newpcb(pclist+i, i);//产生进程
pprint(pclist, PCBNUM);
// poll(pclist, PCBNUM);
generalpriority(pclist,PCBNUM);
// priority(pclist, PCBNUM);//可强占优先法
delete pclist;//释放进程空间
}