【OS课程设计三】模拟进程调度

最新推荐文章于 2023-04-29 17:17:52 发布

array020

最新推荐文章于 2023-04-29 17:17:52 发布

阅读量1.4k

点赞数

文章标签： os 作业 null 算法 input 任务

本文链接：https://blog.csdn.net/damacheng/article/details/6481278

版权

一、设计目的

1、理解PCB

2、理解进程的并发执行

3、理解进程的FCFS、动态优先权和时间片轮转三种调度算法，并模拟实现这三种算法

二、设计要求

1、PCB在本设计中的基本结构

Typedef struct node

{

Char name[10]；/*进程标识符*/

Int prin；/*进程的优先级*/

Int round；/*进程轮转的时间片*/

Int needtime；/*进程还需要的cpu时间*/

Int waittime；/*进程进入系统后等待cpu的时间*/

Char state；/*进程的状态*/

Struct node *next；/*链接指针*/

}PCB

设计三个队列：就绪、完成、运行，其中运行队列中应该只有一个进程。

创建进程，就是用户输入进程的标识符和运行所需时间，系统为其生成一个PCB，存放进程的信息，将新生成的PCB插入就绪队列。进程任务结束，系统将其PCB插入完成队列，该进程就消亡。

2、动态优先权调度算法模拟：

优先权= 1 + 等待时间/需要服务时间----最高响应比优先

(1) 输入一批作业的进程标识和估计运行时间，将其PCB插入就绪队列

(2) 当就绪队列非空、CPU空闲时，计算出每个就绪进程的优先权

(3) 将优先权最高的进程从就绪队列移入运行队列，状态改为运行

(4) 在屏幕上输出当前所有进程的状态和优先权信息(已完成进程不需此项)

(5) 让运行进程执行足够的服务时间

(6) 将运行进程移入完成队列

(7) 提示可以输入新的作业，如果有新作业输入，则转向(1) ，否则转向(2)

(8) 如果就绪队列为空，则结束

3、时间片轮转调度算法模拟

输入一批作业的进程标识和估计运行时间，由其PCB组成就绪队列。时间片轮转调度，系统要给就绪队列的第一个进程分配一个时间片，大小等于n (个时钟周期)，再将它移入运行队列。注意，时间片的大小要比大多数进程的估计运行时间短。当时间片结束的时候，要将没有运行完的进程从运行队列移到就绪队列的末尾，再次进行调度。在每次调度时将所有进程的当前情况显示出来。

4、FCFS调度算法模拟

按一定的顺序输入一批作业的进程标识和估计运行时间，由其PCB按照进程标识输入的顺序组成就绪队列。当就绪队列非空、CPU空闲时，将就绪队列的第一个进程从就绪队列移入运行队列，状态改为运行。以后个步骤类似于2。

linked_list.h

Code:

/*====================================================================
Linked_Queue.h
marcusxing 2009/12/5
====================================================================*/
#ifndef _LINKED_QUEUE_H_
#define _LINKED_QUEUE_H_
typedef struct node_pcb
{
char name[10]; /*进程标识符*/
int pri; /*进程的优先级*/
int round; /*进程轮转的时间片*/
int need_time; /*进程还需要的cpu时间*/
int wait_time; /*进程进入系统后等待cpu的时间*/
char state; /*进程的状态*/
struct node_pcb *next; /*链接指针*/
}PCB;
typedef struct type_linked_queue
{
PCB *tail; /*尾指针*/
PCB *head; /*头指针*/
PCB *max_pri; /*最大优先级长度*/
int size; /*队列长度*/
}Linked_Queue;
void Init_Linked_Queue(Linked_Queue *linked_queue);
int Is_Empty(Linked_Queue *linked_queue);
int En_Queue(Linked_Queue *linked_queue,const char *name,int need_time);
int En_Queue_Copy(Linked_Queue *linked_queue,PCB *copy_pcb);
int De_Queue(Linked_Queue *linked_queue,PCB *ret_pcb);
int De_Queue_Max_Pri(Linked_Queue *linked_queue,PCB *ret_pcb);
void Destroy_Linked_Queue(Linked_Queue *linked_queue);
void Disp_Linked_Queue(Linked_Queue *linked_queue,const char*queue_name);
#endif

linked_queue.c

Code:

/*====================================================================
Linked_Queue.c
marcusxing 2009/12/5
====================================================================*/
#include <stdio.h>
#include <string.h>
#include "Linked_Queue.h"
extern Linked_Queue *ready_queue;
static void Locate_Max_Pri(Linked_Queue *linked_queue);
static void Update_Ready_Queue_Pri();
void Init_Linked_Queue(Linked_Queue *linked_queue)
{
linked_queue->tail = linked_queue->head = linked_queue->max_pri = NULL;
linked_queue->size = 0;
}
int Is_Empty(Linked_Queue *linked_queue)
{
return linked_queue->size == 0;
}
int En_Queue(Linked_Queue *linked_queue,const char *name,int need_time)
{
PCB *new_pcb = (PCB*)malloc(sizeof(PCB));
if(new_pcb != NULL)
{
strcpy(new_pcb->name,name);
new_pcb->round = 3;
new_pcb->need_time = need_time;
new_pcb->wait_time = 0;
new_pcb->state = 'r';
new_pcb->pri = 1 + new_pcb->wait_time / need_time;
new_pcb->next = NULL;
if(Is_Empty(linked_queue))
{
linked_queue->tail = linked_queue->head = linked_queue->max_pri = new_pcb;
}
else
{
linked_queue->tail->next = new_pcb;
linked_queue->tail = new_pcb;
}
linked_queue->size++;
Locate_Max_Pri(linked_queue);
return 1;
}
else
{
printf("allocated error!/n");
return 0;
}
}
int En_Queue_Copy(Linked_Queue *linked_queue,PCB *copy_pcb)
{
PCB *new_pcb = (PCB*)malloc(sizeof(PCB));
if(new_pcb != NULL)
{
strcpy(new_pcb->name,copy_pcb->name);
new_pcb->round = copy_pcb->round;
new_pcb->need_time = copy_pcb->need_time;
new_pcb->wait_time = copy_pcb->wait_time;
new_pcb->state = copy_pcb->state;
new_pcb->pri = copy_pcb->pri;
new_pcb->next = copy_pcb->next;
if(Is_Empty(linked_queue))
{
linked_queue->tail = linked_queue->head = linked_queue->max_pri = new_pcb;
}
else
{
linked_queue->tail->next = new_pcb;
linked_queue->tail = new_pcb;
}
linked_queue->size++;
Locate_Max_Pri(linked_queue);
return 1;
}
else
{
printf("allocated error!/n");
return 0;
}
}
int De_Queue(Linked_Queue *linked_queue,PCB *ret_pcb)
{
PCB *tmp;
if(!Is_Empty(linked_queue))
{
strcpy(ret_pcb->name,linked_queue->head->name);
ret_pcb->round = linked_queue->head->round;
ret_pcb->need_time = linked_queue->head->need_time;
ret_pcb->wait_time = linked_queue->head->wait_time;
ret_pcb->state = linked_queue->head->state;
ret_pcb->pri = linked_queue->head->pri;
ret_pcb->next = linked_queue->head->next;
if(linked_queue->size == 1)
{
linked_queue->tail = linked_queue->head = linked_queue->max_pri = NULL;
}
else
{
tmp = linked_queue->head;
linked_queue->head = linked_queue->head->next;
free(tmp);
}
linked_queue->size--;
Locate_Max_Pri(linked_queue);
return 1;
}
else
{
printf("empty queue error/n");
return 0;
}
}
int De_Queue_Max_Pri(Linked_Queue *linked_queue,PCB *ret_pcb)
{
PCB *tmp;
if(!Is_Empty(linked_queue))
{
strcpy(ret_pcb->name,linked_queue->max_pri->name);
ret_pcb->round = linked_queue->max_pri->round;
ret_pcb->need_time = linked_queue->max_pri->need_time;
ret_pcb->wait_time = linked_queue->max_pri->wait_time;
ret_pcb->state = linked_queue->max_pri->state;
ret_pcb->pri = linked_queue->max_pri->pri;
ret_pcb->next = linked_queue->max_pri->next;
if(linked_queue->size == 1)
{
linked_queue->tail = linked_queue->head = linked_queue->max_pri = NULL;
}
else
{
if(linked_queue->max_pri == linked_queue->head)
{
linked_queue->head = linked_queue->head->next;
}
else
{
tmp = linked_queue->head;
while(tmp->next != linked_queue->max_pri)
{
tmp = tmp->next;
}
if(linked_queue->max_pri == linked_queue->tail)
{
linked_queue->tail = tmp;
}
else
{
tmp->next = linked_queue->max_pri->next;
}
}
free(linked_queue->max_pri);
}
linked_queue->size--;
Locate_Max_Pri(linked_queue);
return 1;
}
else
{
printf("empty queue error/n");
return 0;
}
}
void Destroy_Linked_Queue(Linked_Queue *linked_queue)
{
PCB *tmp = (PCB*)malloc(sizeof(PCB));
while(!Is_Empty(linked_queue))
{
De_Queue(linked_queue,tmp);
}
free(tmp);
}
void Disp_Linked_Queue(Linked_Queue *linked_queue,const char*queue_name)
{
PCB *pcb;
int size;
if(!Is_Empty(linked_queue))
{
pcb = linked_queue->head;
size = linked_queue->size;
printf("=============%s=============/n",queue_name);
while(size--)
{
printf("name:%s ",pcb->name);
printf("wait_time:%d ",pcb->wait_time);
printf("need_time:%d ",pcb->need_time);
printf("pri:%d/n",pcb->pri);
pcb = pcb->next;
}
}
else
{
printf("%s is empty/n",queue_name);
}
}
static void Locate_Max_Pri(Linked_Queue *linked_queue)
{
PCB *tmp;
int i;
int max_pri = 0;
if(linked_queue == ready_queue)
{
for(i = 0,tmp = linked_queue->head ; i < linked_queue->size ; i++,tmp = tmp->next)
{
tmp->pri = 1 + (int)(tmp->wait_time / tmp->need_time);
}
tmp = linked_queue->head;
for(i = 0 ; i < linked_queue->size ; i++)
{
if(tmp->pri > max_pri)
{
max_pri = tmp->pri;
linked_queue->max_pri = tmp;
}
tmp = tmp->next;
}
}
}

schedule.h

Code:

/*====================================================================
schedule.h
marcusxing 2009/12/6
====================================================================*/
#ifndef _SCHEDULE_H_
#define _SCHEDULE_H_
void FCFS();
void Time_Slice();
void Priority_First();
#endif

schedule.c

Code:

/*====================================================================
schedule.c
marcusxing 2009/12/6
====================================================================*/
#include <stdio.h>
#include "Linked_Queue.h"
#include "schedule.h"
extern Linked_Queue *ready_queue;
extern Linked_Queue *finished_queue;
extern Linked_Queue *running_queue;
static void Init_Queues();
static void Clear_Queues();
static void Input_Queues();
void FCFS()
{
Init_Queues();
Input_Queues();
PCB *tmp_pcb = (PCB*)malloc(sizeof(PCB));
printf("start schedule/n");
Disp_Linked_Queue(ready_queue,"ready_queue");
while(!Is_Empty(ready_queue))
{
De_Queue(ready_queue,tmp_pcb);
En_Queue_Copy(running_queue,tmp_pcb);
running_queue->head->state = 'e';
while(running_queue->head->need_time--)
{
sleep(1);
}
De_Queue(running_queue,tmp_pcb);
tmp_pcb->state = 'f';
En_Queue_Copy(finished_queue,tmp_pcb);
Disp_Linked_Queue(ready_queue,"ready_queue");
}
free(tmp_pcb);
Clear_Queues();
}
void Time_Slice()
{
Init_Queues();
Input_Queues();
PCB *tmp_pcb = (PCB*)malloc(sizeof(PCB));
int round;
int flag = 0;
printf("start schedule/n");
Disp_Linked_Queue(ready_queue,"ready_queue");
while(!Is_Empty(ready_queue))
{
De_Queue(ready_queue,tmp_pcb);
En_Queue_Copy(running_queue,tmp_pcb);
running_queue->head->state = 'e';
round = running_queue->head->round;
while(round--)
{
sleep(1);
running_queue->head->need_time--;
if(running_queue->head->need_time == 0)
{
De_Queue(running_queue,tmp_pcb);
tmp_pcb->state = 'f';
En_Queue_Copy(finished_queue,tmp_pcb);
Disp_Linked_Queue(ready_queue,"ready_queue");
flag = 1;
break;
}
}
if(flag)
{
flag = 0;
continue;
}
De_Queue(running_queue,tmp_pcb);
tmp_pcb->state = 'r';
En_Queue_Copy(ready_queue,tmp_pcb);
Disp_Linked_Queue(ready_queue,"ready_queue");
}
free(tmp_pcb);
Clear_Queues();
}
void Priority_First()
{
Init_Queues();
Input_Queues();
int round,i;
int flag = 0;
PCB *tmp_pcb = (PCB*)malloc(sizeof(PCB));
PCB *tmp;
printf("start schedule/n");
Disp_Linked_Queue(ready_queue,"ready_queue");
while(!Is_Empty(ready_queue))
{
De_Queue_Max_Pri(ready_queue,tmp_pcb);
En_Queue_Copy(running_queue,tmp_pcb);
running_queue->head->state = 'e';
round = running_queue->head->round;
while(round--)
{
sleep(1);
running_queue->head->need_time--;
for(i = 0,tmp = ready_queue->head ; i < ready_queue->size ; i++,tmp = tmp->next)
{
tmp->wait_time++;
}
if(running_queue->head->need_time == 0)
{
De_Queue(running_queue,tmp_pcb);
tmp_pcb->state = 'f';
En_Queue_Copy(finished_queue,tmp_pcb);
Disp_Linked_Queue(ready_queue,"ready_queue");
flag = 1;
break;
}
}
if(flag)
{
flag = 0;
continue;
}
De_Queue(running_queue,tmp_pcb);
tmp_pcb->state = 'r';
En_Queue_Copy(ready_queue,tmp_pcb);
Disp_Linked_Queue(ready_queue,"ready_queue");
}
free(tmp_pcb);
Clear_Queues();
}
static void Init_Queues()
{
ready_queue = (Linked_Queue*)malloc(sizeof(Linked_Queue));
finished_queue = (Linked_Queue*)malloc(sizeof(Linked_Queue));
running_queue = (Linked_Queue*)malloc(sizeof(Linked_Queue));
Init_Linked_Queue(ready_queue);
Init_Linked_Queue(finished_queue);
Init_Linked_Queue(running_queue);
}
static void Clear_Queues()
{
Destroy_Linked_Queue(ready_queue);
Destroy_Linked_Queue(finished_queue);
Destroy_Linked_Queue(running_queue);
free(ready_queue);
free(finished_queue);
free(running_queue);
}
static void Input_Queues()
{
int proc_num,i,need_time;
char proc_name[10];
printf("please enter the number of process:");
scanf("%d",&proc_num);
for(i = 0 ; i < proc_num ; i++)
{
printf("please enter the process's name and need time:");
scanf("%s%d",proc_name,&need_time);
En_Queue(ready_queue,proc_name,need_time);
}
}