多级队列反馈调度算法

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct processNode /*进程节点信息*/
{
char name[20]; /*进程的名字*/
int prio; /*进程的优先级*/
int round; /*分配CPU的时间片*/
int cputime; /*CPU执行时间*/
int needtime; /*进程执行所需要的时间*/
char state; /*进程的状态，W——就绪态，R——执行态，F——完成态*/
int count; /*记录执行的次数*/
struct processNode *next; /*链表指针*/
}PCB;
typedef struct Queue /*多级就绪队列节点信息*/
{
PCB *LinkPCB; /*就绪队列中的进程队列指针*/
int prio; /*本就绪队列的优先级*/
int round; /*本就绪队列所分配的时间片*/
struct Queue *next; /*指向下一个就绪队列的链表指针*/
}ReadyQueue;
PCB *running=NULL,*finished=NULL; /*定义三个队列，就绪队列，执行队列和完成队列*/
ReadyQueue *Head = NULL; /*定义第一个就绪队列*/
static ReadyQueue *ready=NULL;
int num; /*进程个数*/
int ReadyNum; /*就绪队列个数*/
void Output(); /*进程信息输出函数*/
void Insertfinished(PCB *in); /*将进程插入到完成队列尾部*/
void InsertReadyQueue(ReadyQueue *in); /*插入就绪队列，规定优先数越小，优先级越低*/
void ReadyQueueInit(); /*创建就绪队列初始化函数*/
void pop(ReadyQueue *queue); /*取得某一个就绪队列中的队头进程*/
void push(PCB *in,ReadyQueue *queue); /*将进程插入到就绪队列尾部*/
void ProcessCreate(); /*进程创建函数*/
void RoundRobin(ReadyQueue *timechip); /*时间片轮转调度算法*/
void MultiDispatch(); /*多级调度算法，每次执行一个时间片*/

void Output() /*进程信息输出函数*/
{
PCB *p = NULL;

p = ready->LinkPCB;
if(p!=NULL)
printf("就绪队列.../n");
while(ready !=NULL)
{
while(p!=NULL)
{
printf("%s/t%d/t%d/t%d/t%d/t/t%c/t/t%d/n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count);
p = p->next;
}
ready = ready->next;
if(ready!=NULL)
p = ready->LinkPCB;
}

p = finished;
if(p!=NULL)
printf("完成队列.../n");
while(p!=NULL)
{
printf("%s/t%d/t%d/t%d/t%d/t/t%c/t/t%d/n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count);
p = p->next;
}
printf("/n/n");
p = running;
if(p!= NULL)
printf("运行队列.../n");
while(p!=NULL)
{
printf("%s/t%d/t%d/t%d/t%d/t/t%c/t/t%d/n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count);
p = p->next;
}
}
void Insertfinished(PCB *in) /*将进程插入到完成队列尾部*/
{
PCB *fst;
fst = finished;

if(finished == NULL)
{
in->next = finished;
finished = in;
}
else
{
while(fst->next != NULL)
{
fst = fst->next;
}
in ->next = fst ->next;
fst ->next = in;
}
printf("the %s has finished!!!/n",in->name);
running = NULL;
Output();
}
void InsertReadyQueue(ReadyQueue *in) /*创建就绪队列，规定优先数越小，优先级越低*/
{
ReadyQueue *fst,*nxt;
fst = nxt = Head;

if(Head == NULL) /*如果没有队列，则为第一个元素*/
{
in->next = Head;
Head = in;
}
else /*查到合适的位置进行插入*/
{
if(in ->prio >= fst ->prio) /*比第一个还要大，则插入到队头*/
{
in->next = Head;
Head = in;

}
else
{
while(fst->next != NULL) /*移动指针查找第一个比它小的元素的位置进行插入*/
{
nxt = fst;
fst = fst->next;
if(in ->prio >= fst ->prio)
{
in ->next = fst;
nxt ->next = in;
return;
}
}

if(fst ->next == NULL) /*已经搜索到队尾，则其优先级数最小，将其插入到队尾即可*/
{
in ->next = fst ->next;
fst ->next = in;
return;
}
}
}
}
void ReadyQueueInit() /*创建就绪队列输入函数*/
{
ReadyQueue *tmp;
int i=0, j=1;

printf("输入就绪队列的个数：/n");
scanf("%d",&ReadyNum);

printf("输入每个就绪队列的CPU时间片：/n");
for(i = 0;i < ReadyNum; i++)
{
if((tmp = (ReadyQueue *)malloc(sizeof(ReadyQueue)))==NULL)
{
perror("malloc failed!!!");
exit(1);
}
printf("请输入就绪队列的时间片 : ");
scanf("%d",&(tmp->round)); /*输入此就绪队列中给每个进程所分配的CPU时间片*/
tmp ->prio = 50 - tmp->round; /*设置其优先级，时间片越高，其优先级越低*/
tmp ->LinkPCB = NULL; /*初始化其连接的进程队列为空*/
tmp ->next = NULL;
InsertReadyQueue(tmp); /*按照优先级从高到低，建立多个就绪队列*/
}

printf("**********Multiple ReadyQueue Information**********/n");
ReadyQueue *rq = Head;

while(rq != NULL){
printf("第 %d 个就绪队列/n",j++);
printf("优先级=%d/t 该就绪队列的时间片=%d/n",rq->prio,rq->round);
rq = rq->next;
}

}
void pop(ReadyQueue *queue) /*取得某一个就绪队列中的队头进程*/
{
running = queue ->LinkPCB;

if(queue ->LinkPCB != NULL)
{
running ->state = 'R';
queue ->LinkPCB = queue ->LinkPCB ->next;
ready = queue;
running ->next = NULL;
}
}
void push(PCB *in,ReadyQueue *queue) /*将进程插入到就绪队列尾部*/
{
PCB *fst;
fst = queue->LinkPCB;

if( queue->LinkPCB == NULL)
{
in->next = queue->LinkPCB;
queue->LinkPCB = in;
}
else
{
while(fst->next != NULL)
{
fst = fst->next;
}
in ->next = fst ->next;
fst ->next = in;
}

printf("push the %s into Ready Queue!!!/n",in->name);
}
void ProcessCreate() /*进程创建函数*/
{
PCB *tmp;
int i,j=1,k;

printf("**********输入进程的个数**********/n");
scanf("%d",&num);

for(i = 0;i < num; i++)
{
if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL)
{
perror("malloc failed!!!");
exit(1);
}
k=j;
printf("输入第%d个进程名字：/n",j++);
scanf("%s",tmp->name);
getchar(); /*吸收回车符号*/
printf("输入第%d个进程需要的时间：/n",k);
scanf("%d",&(tmp->needtime));
tmp ->cputime = 0;
tmp ->state ='W';
tmp ->prio = 50 - tmp->needtime; /*设置其优先级，需要的时间越多，优先级越低*/
tmp ->round = Head ->round;
tmp ->count = 0;
push(tmp,Head); /*按照优先级从高到低，插入到就绪队列*/
}
printf("***The first time ReadyQueue Information***/n");
PCB *prq = Head->LinkPCB;
printf("进程名/t优先级/t轮数/tcpu时间/t需要时间/t进程状态/t计数器/n");
while(prq != NULL)
{
printf("%s/t%d/t%d/t%d/t%d/t/t%c/t/t%d/n",prq->name,prq->prio,prq->round,prq->cputime,prq->needtime,prq->state,prq->count);
prq = prq->next;
}
}
void RoundRobin(ReadyQueue *timechip) /*时间片轮转调度算法*/
{

int flag = 1;

pop(timechip);
while(running != NULL)
{
while(flag)
{
running->count++;
running->cputime++;
running->needtime--;
if(running->needtime == 0) /*进程执行完毕*/
{
running ->state = 'F';
Insertfinished(running);
flag = 0;
}
else if(running->count == timechip ->round)/*时间片用完*/
{
running->state = 'W';
running->count = 0; /*计数器清零，为下次做准备*/
push(running,timechip);
flag = 0;
}
}
flag = 1;
pop(timechip);
}
}
void MultiDispatch() /*多级调度算法，每次执行一个时间片*/
{
int flag = 1;
ReadyQueue *point;
point = Head;
pop(point);
while(running != NULL)
{
if(Head ->LinkPCB!=NULL)
point = Head;
while(flag)
{
running->count++;
running->cputime++;
running->needtime--;
if(running->needtime == 0) /*进程执行完毕*/
{
running ->state = 'F';
Insertfinished(running);
flag = 0;
}
else if(running->count == running->round)/*时间片用完*/
{
running->state = 'W';
running->count = 0; /*计数器清零，为下次做准备*/
if(point ->next!=NULL)
{
running ->round = point->next ->round;/*设置其时间片是下一个就绪队列的时间片*/
push(running,point->next); /*将进程插入到下一个就绪队列中*/
flag = 0;
Output();
}
else
{
RoundRobin(point); /*如果为最后一个就绪队列就调用时间片轮转算法*/
break;
}
}
}
flag = 1;
if(point ->LinkPCB == NULL) /*就绪队列指针下移,进入下一级就绪队列！！！*/
point =point->next;
if(point ->next ==NULL)
{
RoundRobin(point);
break;
}
pop(point);
}

}

int main(void)
{
ReadyQueueInit(); /*创建就绪队列*/
ProcessCreate(); /*创建就绪进程队列*/
MultiDispatch(); /*算法开始*/
return 0;
}