模拟简单进程调度实验

一、实验目的及要求
1. 用C语言编写和调试一个模拟进程调度程序，以加深对进程的概念及进程调度算法的理解，模拟过程的数据结构和算法符合主流操作系统的进程调度规则(从第2点开始给出过程规则)。
2. 进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）。
3. 每个进程有一个进程控制块（PCB）表示。进程控制块可以包含如下信息：进程名、优先数、需要运行时间、已用CPU时间、进程状态等等。
4. 进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
5. 每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
6. 进程的运行时间以时间片为单位进行计算。
7. 就绪进程获得CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。
8. 采用最高优先数算法的动态优先数法则控制进程：如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
9. 每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
10. 重复以上过程，直到所要进程都完成为止。

二、实验内容与步骤

1．数据结构
1.1 进程控制块结构PCB：是struct定义的结构体，定义如下：
typedef struct pcb
{
    char qname[20];/*进程名*/
    char state;    /*进程状态*/
    int super;     /*进程优先级*/
    int ndtime;    /*进程需要运行的时间*/
    int runtime;   /*进程已运行的时间*/
    int cpu;       /*进程当前获得的时间片大小*/
}PCB;

1.2  队列结点Node，结点储存PCB信息，定义如下：
typedef struct node
{
    PCB data;              /*结点数据*/
    struct node *next; /*指向下一结点的指针*/
}Node;

1.3 由队列结点Node扩展的队列Queue,定义如下：
typedef struct queue
{
    Node *front;/*队首*/
    Node *rear;/*队尾*/
}Queue;

2．相关函数
2.1 判断一个队列q是否为空的函数int is_empty(Queue *q);
2.2 将进程控制块x加入队列q的函数void enqueue(PCB x,Queue *q);
2.3 删除队列q的队首进程，将其值赋给x并修改状态的函数void dequeue(PCB *x,Queue *q);
   该函数将队列q的队首进程删除，由于可能该进程未运行完毕，需进入下一优先级队列， 所以先修改其结构体内成员变量：已运行时间为上次已运行时间加上这次获得的cpu时间；优先级减1（若该进程已是最低优先级，则将在主控过程中恢复）；下次获得的时间片为这次的时间片加1。然后将修改后的进程赋给一个临时PCB变量x，以便将x插入下一优先级队列。
2.4 主函数
   利用上述的数据结构和函数实现模拟进程调度。

3. 进程产生模拟

通过标准输入模拟产生进程：先要求输入进程数目，再依次输入各个进程的进程名、进程优先数、进程需要运行的时间。

三、参考代码

#include<stdio.h>
#include<string.h>
#include<malloc.h>
#include<conio.h>
#define PCB_LEN sizeof(PCB)
#define NODE_LEN sizeof(Node)
#define QUEUE_LEN sizeof(Queue)
/*进程控制块结构PCB*/
typedef struct pcb
{
	char qname[20];/*进程名*/
    char state;    /*进程状态*/
	int super;     /*进程优先级*/
	int ndtime;    /*进程需要运行的时间*/
	int runtime;   /*进程已运行的时间*/
	int cpu;       /*进程当前获得的时间片大小*/
}PCB;
/*队列结点，结点储存PCB信息*/
typedef struct node
{
	PCB data;
    struct node *next;
}Node;
/*实现进程控制块的队列*/
typedef struct queue
{
	Node *front;
	Node *rear;
}Queue;
/*判断队列是否为空*/
int is_empty(Queue *q)
{
	if(q->front)
		return 0;
	else
		return 1;
}
/*将进程控制块x加入队列q*/
void enqueue(PCB x,Queue *q)
{
    Node *p=(Node *)malloc(NODE_LEN);
	(p->data).state=x.state;
	(p->data).super=x.super;
	(p->data).ndtime=x.ndtime;
	(p->data).runtime=x.runtime;
	(p->data).cpu=x.cpu;
	strcpy((p->data).qname,x.qname);
	p->next=0;
	if(q->front)
		q->rear->next=p;
	else
		q->front=p;
	q->rear=p;
}
/*删除队列q的队首进程，将其值赋给x并修改状态*/
void dequeue(PCB *x,Queue *q)
{
	Node *p=(Node *)malloc(NODE_LEN);
    if(is_empty(q))
		return;
	/*进入下一优先级队列之前修改状态*/
	x->state='W';/*状态改为就绪*/
	strcpy(x->qname,(q->front->data).qname);
	/*已运行时间为上次已运行时间加上这次获得的cpu时间*/
	x->runtime=(q->front->data).runtime+(q->front->data).cpu;
	/*优先级减1，若该进程已是最低优先级，则将在主控过程中恢复*/
	x->super=(q->front->data).super-1;
	x->ndtime=(q->front->data).ndtime;
	/*下次获得的时间片为这次的时间片加1*/
	x->cpu=(q->front->data).cpu+1;
	p=q->front;
	q->front=q->front->next;
	free(p);
}
/*主控过程*/
void main()
{
	Queue *queue=NULL;/*设置就绪队列数组*/
	Node *wait=(Node *)malloc(NODE_LEN);
	PCB x;
	int numberOFcourse,i,j,super,time;
	int hight=0,num=0;
	int temp_ndtime,temp_runtime,temp_cpu;
	char name[20];
	printf("\n请输入进程总个数?");
	scanf("%d",&numberOFcourse);
	/*为队列数组开辟空间，每个数组表示不同的优先级队列*/
	queue=(Queue *)calloc(numberOFcourse,QUEUE_LEN);
	/*输入各进程信息并初始化，并将其加入相应的优先级队列*/
	for(i=0;i<numberOFcourse;i++)
	{
		printf("\n进程号 NO.%d\n",i);
		printf("\n输入进程名：");
		scanf("%s",name);
		printf("\n输入进程优先数：");
		scanf("%d",&super);
		if(super>hight)
			hight=super;
		printf("\n输入进程运行时间：");
		scanf("%d",&time);
		strcpy(x.qname,name);
		x.state='W';
        x.super=super;
		x.ndtime=time;
		x.runtime=0;
		x.cpu=1;
		enqueue(x,&queue[super-1]);
	}
	printf("\n\n");
	/*进程调度过程*/
	for(i=hight-1;i>=0;i--)
	{
		/*从最高优先级队列开始调度进程，
		直到该队列为空，则调度下一优先级队列*/
		while(!is_empty(&queue[i]))
		{
			num++;/*调度次数*/
			printf("按任一键继续......\n");
			getch();
			printf("The execute number:%d\n\n",num);
			/*打印正在运行进程*/
			((queue[i].front)->data).state='R';
			printf("******当前工作的进程是：%s\n",((queue[i].front)->data).qname);
			printf("qname    state    super    ndtime    runtime\n");
			printf("%s        ",((queue[i].front)->data).qname);
            printf("R         ");
			printf("%d        ",(((queue[i].front)->data).super));
            printf("%d        ",(((queue[i].front)->data).ndtime));
			printf("%d\n\n",(((queue[i].front)->data).runtime));
			/*计算一个进程运行一个时间片后，还需要运行的时间temp_time*/
            temp_ndtime=((queue[i].front)->data).ndtime;
			temp_runtime=((queue[i].front)->data).runtime;
            temp_cpu=((queue[i].front)->data).cpu;
			temp_ndtime=temp_ndtime-temp_runtime-temp_cpu;
			/*若该进程已运行完毕*/
			if(temp_ndtime<=0)
			{
				/*打印已完成信息，并将其删除出队列*/
				printf("进程[%s]已完成\n\n",((queue[i].front)->data).qname);
                ((queue[i].front)->data).state='F';
                dequeue(&x,&queue[i]);
			}
			/*若该进程未运行完毕*/
			else
			{
                dequeue(&x,&queue[i]);/*将其删除出当前队列*/
				/*若原优先级不是最低优先级，则插入下一优先级队列*/
				if(i>0)
					enqueue(x,&queue[i-1]);
				/*若原优先级是最低优先级，则插入当前队列末尾*/
				else
				{
					/*由于删除操作中将优先级减1，所以在此恢复*/
					x.super=x.super+1;
                    enqueue(x,&queue[i]);
				}
			}
			/*打印就绪队列状态*/
            printf("******当前就绪队列状态为：\n");
			for(j=i;j>=0;j--)
			{
				if(queue[j].front)
				{
					wait=queue[j].front;
					while(wait)
					{
						printf("qname    state    super    ndtime    runtime\n");
			            printf("%s        ",(wait->data).qname);
                        printf("W         ");
			            printf("%d        ",(wait->data).super);
                        printf("%d        ",(wait->data).ndtime);
			            printf("%d\n\n",((wait->data).runtime));
                        wait=wait->next;
					}
                }
			}
			printf("\n");
		}
	}
	/*结束*/
	printf("进程已经全部完成\n");
	free(wait);
	free(queue);
	getch();
}

四、实验结果与数据处理

【输入输出样例】

请输入进程总个数?4

进程号 NO.0

输入进程名：aa

输入进程优先数：2

输入进程运行时间：2

进程号 NO.1

输入进程名：vv

输入进程优先数：3

输入进程运行时间：2

进程号 NO.2

输入进程名：rr

输入进程优先数：1

输入进程运行时间：3

进程号 NO.3

输入进程名：kk

输入进程优先数：2

输入进程运行时间：1

按任一键继续......
The execute number:1

******当前工作的进程是：vv
qname    state    super    ndtime    runtime
vv        R         3        2        0

******当前就绪队列状态为：
qname    state    super    ndtime    runtime
aa        W         2        2        0

qname    state    super    ndtime    runtime
kk        W         2        1        0

qname    state    super    ndtime    runtime
vv        W         2        2        1

qname    state    super    ndtime    runtime
rr        W         1        3        0

按任一键继续......
The execute number:2

******当前工作的进程是：aa
qname    state    super    ndtime    runtime
aa        R         2        2        0

******当前就绪队列状态为：
qname    state    super    ndtime    runtime
kk        W         2        1        0

qname    state    super    ndtime    runtime
vv        W         2        2        1

qname    state    super    ndtime    runtime
rr        W         1        3        0

qname    state    super    ndtime    runtime
aa        W         1        2        1

按任一键继续......
The execute number:3

******当前工作的进程是：kk
qname    state    super    ndtime    runtime
kk        R         2        1        0

进程[kk]已完成

******当前就绪队列状态为：
qname    state    super    ndtime    runtime
vv        W         2        2        1

qname    state    super    ndtime    runtime
rr        W         1        3        0

qname    state    super    ndtime    runtime
aa        W         1        2        1

按任一键继续......
The execute number:4

******当前工作的进程是：vv
qname    state    super    ndtime    runtime
vv        R         2        2        1

进程[vv]已完成

******当前就绪队列状态为：
qname    state    super    ndtime    runtime
rr        W         1        3        0

qname    state    super    ndtime    runtime
aa        W         1        2        1

按任一键继续......
The execute number:5

******当前工作的进程是：rr
qname    state    super    ndtime    runtime
rr        R         1        3        0

******当前就绪队列状态为：
qname    state    super    ndtime    runtime
aa        W         1        2        1

qname    state    super    ndtime    runtime
rr        W         1        3        1

按任一键继续......
The execute number:6

******当前工作的进程是：aa
qname    state    super    ndtime    runtime
aa        R         1        2        1

进程[aa]已完成

******当前就绪队列状态为：
qname    state    super    ndtime    runtime
rr        W         1        3        1

按任一键继续......
The execute number:7

******当前工作的进程是：rr
qname    state    super    ndtime    runtime
rr        R         1        3        1

进程[rr]已完成

******当前就绪队列状态为：

进程已经全部完成

五、总结

        本程序利用标准输入输出模拟了进程调度过程。输入各个进程的优先级和需要运行的时间等信息，输出给出了每进行一次调度的运行进程、就绪队列、以及各个进程的 PCB信息，每当一个进程完成运行，输出该进程已完成的信息，最后当所有进程都完成后给出所有进程都完成的信息。