操作系统调度算法练习

berdeng

已于 2023-05-27 19:36:36 修改

阅读量125

点赞数

文章标签：算法 c语言

于 2023-05-27 18:39:03 首次发布

本文链接：https://blog.youkuaiyun.com/mozi196/article/details/130904449

版权

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_PROCESS 20 //最大进程数量

typedef struct PCB{
char name[10];
int prio;
int round;
int cputime;
int needtime;
int count;
char state;
struct PCB *next;
} PCB;

typedef struct queue{
PCB *front;
PCB *rear;
int size;
} Queue;

Queue *initQueue(){
Queue *q = (Queue *)malloc(sizeof(Queue));
q->front = q->rear = NULL;
q->size = 0;
return q;
}

void enque(Queue *q, PCB *p){
if(q->size == 0){
q->front = q->rear = p;
p->next = NULL;
}
else{
q->rear->next = p;
q->rear = p;
p->next = NULL;
}
q->size++;
}

PCB *deque(Queue *q){
if(q->size == 0){
return NULL;
}
else{
PCB *p = q->front;
q->front = q->front->next;
q->size--;
return p;
}
}

typedef struct rrqueue{
PCB *data[MAX_PROCESS];
int front, rear, size;
} RRQueue;

RRQueue *initRRQueue(){
RRQueue *q = (RRQueue *)malloc(sizeof(RRQueue));
q->front = q->rear = 0;
q->size = 0;
return q;
}

void rrEnque(RRQueue *q, PCB *p){
if(q->size >= MAX_PROCESS){
printf("RR队列已满\n");
exit(0);
}
q->data[q->rear] = p;
q->rear = (q->rear + 1) % MAX_PROCESS;
q->size++;
}

PCB *rrDeque(RRQueue *q){
if(q->size == 0){
return NULL;
}
else{
PCB *p = q->data[q->front];
q->front = (q->front + 1) % MAX_PROCESS;
q->size--;
return p;
}
}

void FCFS(Queue *q){
printf("========== FCFS调度模拟 ==========\n");
int clock = 0;
int i, total_time = 0, total_count = 0, total_wait = 0;
PCB *p = NULL;
printf("进程号进入时间运行时间开始时间结束时间周转时间带权周转时间等待时间\n");
while(q->size > 0){
p = deque(q);
total_wait += clock - p->round;
if(p->round > clock){
clock = p->round;
}
p->state = 'R';//ready状态
p->count = clock + p->needtime;//计算结束时间
total_time += p->needtime;
total_count += p->count - p->round;
int m=clock - p->round;
if(m<0){
m=0;
}
printf("%s\t %d\t %d\t %d\t %d\t %d\t %.2f\t %d\n", p->name, p->round, p->needtime, clock, p->count, p->count - p->round, (float)(p->count - p->round) / p->needtime, m);
clock = p->count;
free(p);
}
//printf("平均周转时间：%.2f，平均带权周转时间：%.2f，平均等待时间：%.2f\n", (float)total_count/MAX_PROCESS, (float)total_count/total_time, (float)total_wait/MAX_PROCESS);
}
void SJF(Queue *q){
printf("========== SJF调度模拟 ==========\n");
int clock = 0, i, total_time = 0, total_count = 0, total_wait = 0;
PCB *p = NULL, *tmp = NULL;
Queue *tmpq = initQueue();
printf("进程号进入时间运行时间开始时间结束时间周转时间带权周转时间等待时间\n");
while(q->size > 0 || tmpq->size > 0){
while(q->size > 0 && q->front->round <= clock){
enque(tmpq, deque(q));//把能运行的进程放入候选队列
}
if(tmpq->size > 0){//候选队列不为空
if(tmpq->front->state == 'W'){//之前在等待中的进程
tmp = deque(tmpq);
tmp->state = 'R';
tmp->count = clock + tmp->needtime;
total_time += tmp->needtime;
total_count += tmp->count - tmp->round;
total_wait += clock - tmp->round;
int m1=clock - tmp->round;
if(m1<0){
m1=0;
}
printf("%s\t %d\t %d\t %d\t %d\t %d\t %.2f\t %d\n", tmp->name, tmp->round, tmp->needtime, clock, tmp->count, tmp->count - tmp->round, (float)(tmp->count - tmp->round) / tmp->needtime, m1);
clock = tmp->count;
free(tmp);
continue;
}
//寻找最短的进程
tmp = tmpq->front;
PCB *p = tmpq->front->next;
while(p != NULL){
if(p->needtime < tmp->needtime){
tmp = p;
}
p = p->next;
}
tmp->state = 'R';
tmp->count = clock + tmp->needtime;
total_time += tmp->needtime;
total_count += tmp->count - tmp->round;
total_wait += clock - tmp->round;
int m2=clock - tmp->round;
if(m2<0){
m2=0;
}
printf("%s\t %d\t %d\t %d\t %d\t %d\t %.2f\t %d\n", tmp->name, tmp->round, tmp->needtime, clock, tmp->count, tmp->count - tmp->round, (float)(tmp->count - tmp->round) / tmp->needtime, m2);
clock = tmp->count;
free(deque(tmpq));
continue;
}

if(q->size > 0){//候选队列为空，继续处理进入队列的进程
p = deque(q);
p->state = 'R';
p->count = clock + p->needtime;
total_time += p->needtime;
total_count += p->count - p->round;
total_wait += clock - p->round;

int m3=clock - p->round;
if(m3<0){
m3=0;
}
printf("%s\t %d\t %d\t %d\t %d\t %d\t %.2f\t %d\n\n", p->name, p->round, p->needtime, clock, p->count, p->count - p->round, (float)(p->count - p->round) / p->needtime, m3);
clock = p->count;
free(p);
continue;
}

clock++;//队列为空，时间片加1
}
}
void Priority(Queue *q){
   printf("========== 优先级调度模拟 ==========\n");
   int clock = 0, i, total_time = 0, total_count = 0, total_wait = 0;
   PCB *p = NULL, *tmp = NULL;
   Queue *tmpq = initQueue();
   printf("进程号进入时间优先级运行时间开始时间结束时间周转时间带权周转时间等待时间\n");
   while(q->size > 0 || tmpq->size > 0){
       while(q->size > 0 && q->front->round <= clock){
           enque(tmpq, deque(q));//把能运行的进程放入候选队列
   }
   if(tmpq->size > 0){//候选队列不为空
if(tmpq->front->state == 'W'){//之前在等待中的进程
tmp = deque(tmpq);
tmp->state = 'R';
tmp->count = clock + tmp->needtime;
total_time += tmp->needtime;
total_count += tmp->count - tmp->round;
total_wait += clock - tmp->round;
int m4= clock - tmp->round;
if(m4<0){
   m4=0;
           }
printf("%s\t %d\t %d\t %d\t %d\t %d\t %d\t %.2f\t %d\n", tmp->name, tmp->round, tmp->prio, tmp->needtime, clock, tmp->count, tmp->count - tmp->round, (float)(tmp->count - tmp->round) / tmp->needtime,m4);
clock = tmp->count;
free(tmp);
continue;
}
//寻找最高优先级的进程
tmp = tmpq->front;
PCB *p = tmpq->front->next;
while(p != NULL){
if(p->prio < tmp->prio){
tmp = p;
}
p = p->next;
}
tmp->state = 'R';
tmp->count = clock + tmp->needtime;
total_time += tmp->needtime;
total_count += tmp->count - tmp->round;
total_wait += clock - tmp->round;
int m5=clock - tmp->round;
if(m5<0){
   m5=0;
       }
printf("%s\t %d\t %d\t %d\t %d\t %d\t %d\t %.2f\t %d\n", tmp->name, tmp->round, tmp->prio, tmp->needtime, clock, tmp->count, tmp->count - tmp->round, (float)(tmp->count - tmp->round) / tmp->needtime, m5);
clock = tmp->count;
free(deque(tmpq));
continue;
}

if(q->size > 0){//候选队列为空，继续处理进入队列的进程
p = deque(q);
p->state = 'R';
p->count = clock + p->needtime;
total_time += p->needtime;
total_count += p->count - p->round;
total_wait += clock - p->round;
int m6=clock - p->round;
if(m6<0){
m6=0;
}
printf("%s\t %d\t %d\t %d\t %d\t %d\t %d\t %.2f\t %d\n", p->name, p->round, p->prio, p->needtime, clock, p->count, p->count - p->round, (float)(p->count - p->round) / p->needtime, m6);
clock = p->count;
free(p);
continue;
}

clock++;//队列为空，时间片加1
}
}
//RR
void RR(RRQueue *q, int slice){
printf("========== RR调度模拟 ==========\n");
int clock = 0, i, total_time = 0, total_count = 0, total_wait = 0;
int tmpTime = 0;
PCB *p = NULL;
printf("进程号进入时间运行时间开始时间结束时间周转时间带权周转时间等待时间\n");
while(q->size > 0){
p = rrDeque(q);
p->state = 'R';
if(p->needtime > slice){//剩余时间大于时间片，分多次处理
total_wait += clock - p->round;
total_time += slice;
printf("%s\t %d\t %d\t %d\t -\t -\n", p->name, p->round, slice, clock);
tmpTime = clock + slice;
p->needtime -= slice;
clock = tmpTime;
rrEnque(q, p);//放回队列尾部，下次继续执行
}
else{//剩余时间小于等于时间片，完成处理
total_wait += clock - p->round;
total_time += p->needtime;
p->count = clock + p->needtime;
total_count += p->count - p->round;
int m7=clock - p->round;
if(m7<0){
m7=0;
}
printf("%s\t %d\t %d\t %d\t %d\t %d\t %.2f\t %d\n", p->name, p->round, p->needtime, clock, p->count, p->count - p->round, (float)(p->count - p->round) / p->needtime, m7);
clock = p->count;
free(p);
}
}
}

int main(){
int i, algo, time_slice;
char name[10];
int prio, rund, needt;
PCB *p;
Queue *q = initQueue();
RRQueue *rq = initRRQueue();
printf("请输入要模拟的算法（1：FCFS（先来先服务）；2：SJF（短作业优先）；3：优先级调度；4：RR（时间片轮转））");
scanf("%d", &algo);

if(algo == 4){
printf("请输入时间片大小：");
scanf("%d", &time_slice);
}

printf("请输入进程数：");
scanf("%d", &i);

while(i--){
printf("请依次输入进程名、进入时间、运行时间、优先级：\n");
scanf("%s%d%d%d", name, &rund, &needt, &prio);
p = (PCB *)malloc(sizeof(PCB));
strcpy(p->name, name);
p->prio = prio;
p->round = rund;
p->cputime = 0;
p->needtime = needt;
p->count = 0;
p->state = 'W';//wait状态
p->next = NULL;
if(algo == 4){
rrEnque(rq, p);
}
else{
enque(q, p);
}
}

switch(algo){
case 1://FCFS算法
FCFS(q);
break;
case 2://SJF算法
SJF(q);
break;
case 3://优先级调度算法
Priority(q);
break;
case 4://RR算法
RR(rq, time_slice);
break;
default:
printf("不支持的算法\n");
break;
}
return 0;
}