进程调度实验【实验报告】

实验一进程调度实验
专业：信息管理与信息系统
学号：2014******
姓名：陈*
实验日期：2016年11月11日
一、实验目的
通过本实验，采用动态优先权优先的调度算法编写和调试一个简单的进程调度程序，加深理解了有关进程控制块、进程队列的概念，并体会了优先权调度算法的具体实施办法。

二、实验要求
用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解．
三、实验方法内容
1.算法设计思路（流程图）
开始
输入所有进程到一个链表中
是否所有进程都已完成
结束
Y
i = 1,m = 0
在就绪队列中找到优先级最高的进程，用P1表示，state 设为R
用P2指向链表第一
个节点
P2所指进程state = F ？
N
P2所指进程state = R ？
N
Priority – 2，CPUTime + 1，AllTime –1，
Y
AllTime = 0？
Y
N
State 设为F ，m = 1
CPUTime % StartBlock = 0 ？
state 设为B ，m = 1
Y
N
P2所指进程state = B ？
BolckTime - 1
BlockTime = 0?
State 设为 W Y
Y
N P2所指进程state = W ？
N
Priority + 1
Y
N
P2指向下一个节点
P2已指向链表末尾？
N
Y
M = 1 ？
i <= 2 ?
i + 1
Y
N
N
Y
N
Y
2.算法中用到的数据结构
（1）首先定义一个结构体，用以保存一个进程的各种信息，最后一个指针便于将所有进程形成一个链表
typedef struct pcb{
int id;
int arriveTime; //到达时间
int priority;
int cpuTime;
int allTime;
int startBlock;
int blockTime;
char state;
struct pcb *next;
}PCB;
（2）接着建立一个链表存储所有进程，以结构体PCB为节点（头节点为空节点，从第二个节点开始存储数据）。

链表建立过程如下：
int i = 0;
PCB *head,*p1,*p2;
head = (PCB *)malloc(sizeof(PCB)); //创建链表头
p2 = head;
//三个进程
for(i = 0; i < 3; i++){
p1 = (PCB *)malloc(sizeof(PCB));
//设置进程的初始状态，各个数据已经保存在对应的各个数组中
p1->id = pcId[i];
p1->priority = priority[i];
p1->cpuTime = cpuTime[i];
p1->allTime = allTime[i];
p1->startBlock = startBlock[i];
p1->blockTime = blockTime[i];
p1->state = 'W'; //初始状态为就绪
p2->next = p1;
p2 = p1;
}
p2->next = NULL; //表尾指针设为空指针，表示链表结束
3.主要模块（函数名）
如下：
（1）创建初始队列，用链表存储
PCB *createLink(){}；
（2）输出链表中所有进程的状态
void printLink(PCB *head, int time);
（3）判断是否所有进程都已完成
int isFinish(PCB *head);
（4）判断是否所有未完成的进程都处于阻塞状态int isBlock(PCB *head);
（5）获得当前时刻优先权最高且处于就绪状态的进程PCB *getHighPriority(PCB *head);
（6）运行（调度函数，在这里展示所有代码）
void run(PCB *head){};
所有代码如下：
#include<stdio.h>
#include<malloc.h>
//三个进程的初始状态
int pcId[] = { 0, 1, 2};
int priority[] = { 6, 8, 5};
int cpuTime[] = { 0, 0, 0};
int allTime[] = { 7, 7, 6};
int startBlock[] = { 6, 4, 2};
int blockTime[] = { 3, 8, 6};
typedef struct pcb{
int id;
int arriveTime; //到达时间
int priority;
int cpuTime;
int allTime;
int startBlock;
int blockTime;
char state;
struct pcb *next;
}PCB;
//创建初始队列，用链表存储
PCB *createLink(){
//int pcNum = 0; //进程个数
int i = 0;
PCB *head,*p1,*p2;
head = (PCB *)malloc(sizeof(PCB)); //创建链表头
p2 = head;
for(i = 0; i < 3; i++){
p1 = (PCB *)malloc(sizeof(PCB));
p1->arriveTime = i; //进程到达时间为输入时间
//设置进程的初始状态
p1->id = pcId[i];
p1->priority = priority[i];
p1->cpuTime = cpuTime[i];
p1->allTime = allTime[i];
p1->startBlock = startBlock[i];
p1->blockTime = blockTime[i];
p1->state = 'W'; //初始状态为就绪w
p2->next = p1;
p2 = p1;
}
p2->next = NULL; //表尾指针设为空指针，表示链表结束
return head;
}
//输出所有队列中所有进程的状态
void printLink(PCB *head, int time){
printf("当前时刻为：%d\n",time);
printf("ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE\n");
PCB *p1 = head->next;
while(p1 != NULL){
printf("%d %d %d %d %d %d %c\n"
,p1->id,p1->priority,p1->cpuTime,p1->allTime,p1->startBlock,p1->blockTime,p 1->state);
p1 = p1->next; //指向下一个节点
}
printf("\n"); //空行
return ;
}
//判断是否所有进程都已完成
int isFinish(PCB *head){
PCB *p1 = head->next;
while(p1 != NULL){
if(p1->state != 'F') //如果有未完成的进程，返回0
return 0;
p1 = p1->next;
}
return 1; //所有进程都完成了，返回1
}
//判断是否所有未完成的进程都处于阻塞状态
int isBlock(PCB *head){
PCB *p1 = head->next;
while(p1 != NULL){
if(p1->state != 'F' && p1->state != 'B') //如果有未阻塞的进程，返回0 return 0;
p1 = p1->next;
}
return 1; //所有进程都阻塞了，返回1
}
//获得当前时刻优先权最高且处于就绪状态的进程
PCB *getHighPriority(PCB *head){
int pri = -32768; //优先权
PCB *p1,*p2 = NULL;
p1 = head->next;
while(p1 != NULL){
if(p1->state == 'W' && p1->priority > pri){
pri = p1->priority; //获得优先权更高的进程
p2 = p1;
}
p1 = p1->next;
}
return p2; //返回优先权最高的进程
}
//运行
void run(PCB *head){
int time = 0; //时刻
int i;
int mark;
PCB *p1,*p2;
while(!isFinish(head)){
mark = 0;
p1 = getHighPriority(head); //p1所指进程优先权最高，获得运行资格
if(p1 != NULL){
p1->state = 'R';
}
for(i = 1;i <= 2; i++){ //运行两个时间片
p2 = head->next;
while(p2 != NULL){
if(p2 == p1 && p2->state != 'F'){
p2->priority -= 2; //进程每运行一个时间片，优先权减2。

p2->cpuTime++;
p2->allTime--;
if(p2->allTime == 0){
p2->state = 'F';
mark = 1;
}
else if(p2->cpuTime % p2->startBlock == 0){
p2->state = 'B'; //如果进程运行了startBlock个时间片，进入阻塞状态
mark = 1;
}
}
else if(p2 != p1 && p2->state != 'F'){
if(p2->state == 'W'){
p2->priority++; //进程在就绪队列中呆一个时间片，优先权增加1
}
if(p2->state == 'B'){
p2->blockTime --;
if(p2->blockTime == 0){
p2->state = 'W'; //阻塞时间结束，回到就绪队列
p2->blockTime = blockTime[p2->id];
}
}
}
p2 = p2->next;
}
time++;
printLink(head,time);
if(isBlock(head))
break;
if(mark == 1)
break;
}
if(p1 != NULL && p1->state == 'R'){
p1->state = 'W';
}
}
}
//主函数
int main(){
PCB *head;
head = createLink();
printLink(head,0);
run(head);
return 0;
}
四、实验结果
1.执行结果：
当前时刻为：0
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 6 0 7 6 3 W
1 8 0 7 4 8 W
2 5 0 6 2 6 W
当前时刻为：1
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 7 0 7 6 3 W
1 6 1 6 4 8 R
2 6 0 6 2 6 W
当前时刻为：2
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 8 0 7 6 3 W
1 4
2 5 4 8 R
2 7 0 6 2 6 W
当前时刻为：3
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 6 1 6 6 3 R
1 5
2 5 4 8 W
2 8 0 6 2 6 W
当前时刻为：4
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 4 2 5 6 3 R
1 6
2 5 4 8 W
2 9 0 6 2 6 W
当前时刻为：5
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 5 2 5 6 3 W
1 7
2 5 4 8 W
2 7 1 5 2 6 R
当前时刻为：6
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 6 2 5 6 3 W
1 8
2 5 4 8 W
2 5 2 4 2 6 B
当前时刻为：7
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 7 2 5 6 3 W
1 6 3 4 4 8 R
2 5 2 4 2 5 B
当前时刻为：8
I D PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 8 2 5 6 3 W
1 4 4 3 4 8 B
2 5 2 4 2 4 B
当前时刻为：9
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 6 3 4 6 3 R
1 4 4 3 4 7 B
2 5 2 4 2
3 B
当前时刻为：10
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 4 4 3 6 3 R
1 4 4 3 4 6 B
2 5 2 4 2 2 B
当前时刻为：11
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 2 5 2 6 3 R
1 4 4 3 4 5 B
2 5 2 4 2 1 B
当前时刻为：12
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 0 6 1 6 3 B
1 4 4 3 4 4 B
2 5 2 4 2 6 W
当前时刻为：13
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 0 6 1 6 2 B
1 4 4 3 4 3 B
2 3 3 3 2 6 R
当前时刻为：14
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 0 6 1 6 1 B
1 4 4 3 4
2 B
2 1 4 2 2 6 B
当前时刻为：15
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 0 6 1 6 3 W
1 4 4 3 4 1 B
2 1 4 2 2 5 B
当前时刻为：16
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 1 6 1 6 3 W
1 4 4 3 4 8 W
2 1 4 2 2 4 B
当前时刻为：17
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 2 6 1 6 3 W
1 2 5 2 4 8 R
2 1 4 2 2
3 B
当前时刻为：18
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 3 6 1 6 3 W
1 0 6 1 4 8 R
2 1 4 2 2 2 B
当前时刻为：19
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 1 7 0 6 3 F
1 1 6 1 4 8 W
2 1 4 2 2 1 B
当前时刻为：20
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STAT E
0 1 7 0 6 3 F
1 -1 7 0 4 8 F
2 1 4 2 2 6 W
当前时刻为：21
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 1 7 0 6 3 F
1 -1 7 0 4 8 F
2 -1 5 1 2 6 R
当前时刻为：22
ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE
0 1 7 0 6 3 F
1 -1 7 0 4 8 F
2 -
3 6 0 2 6 F 2.结果分析
（1）每对一个进程进行一次操作（优先级加减、CPUtime加减等）后，就要判断是否要进行状态改变。

情况如下：
①：运行状态的进程运行一个时间片之后，CPUTime加1，AllTime
加1，此时判断AllTime是否为零，为零则该进程状态设为F（完成），
否则不变；再判断CPUTime对startTime求余是否为零，为零则该进
程状态设为B（阻塞），否则不变；
②：阻塞状态的进程经过一个时间片之后，blockTime减1，此时判
断blockTime是否为零，为零则该进程状态设为W（就绪），否则不
变；
（2）若所有未完成的进程都进入阻塞状态，则按照对阻塞进程的操作进行两个时间片。

再判断是否有进程可以获得运行资格。

3.实验总结
（1）通过本实验，我更加理解了什么是进程，也对高优先级调度方法有了更深层次的了解。

借助本实验，我也加深了对其他调度算法理解。

（2）本次试验，我通过实践，加深了理论知识。

通过理论与实践的结合，
更好地掌握了知识。

这也是以后要继续实行的学习方法。

（3）C语言编程技能与操作系统知识的相结合，让我在提高编程能力的同
时，加强了与实际问题的结合，提高了对实际问题的解决能力。