广东工业大学 操作系统实验报告

操作系统实验报告

学院计算机

专业计算机科学与技术班级200X级X班学号XXXXXXXX 姓名XXX

指导教师孙为军

学号：XXXXXXXX 姓名：XXX 协作者：________实验__一__题目__ 进程调度___第12 周星期__四_

一、实验目的

用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。

二、实验内容和要求

设计一个有N个进程并发的进程调度程序。要求采用最高级优先数优先算法。

每个进程有一个进程控制块PCB表示。进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

进程的优先数以及需要的运行时间可以事先人为地指定。进程的到达时间为进程输入的时间。进程的运行时间以及时间片为单位进行计算。

每个进程的状态可以是就绪W wait、运行R run、完成 F finish三种状态之一。

就绪进程获得CPU后就只能进行一个时间片。用已占用CPU时间加1来表示。

如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤销该进程，如果运行一个时间片后进程的已占用CPU时间还未到达所需要的运行时间，也就是进程还需要继续运行，此时，应将进程的优先数减1，然后把它插入就绪队列等待CPU。每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进程检查。

重复以上过程，知道所有进程完成为止。

三、实验原理及设计方案

1、进程调度算法：采用多级反馈队列调度算法。其基本思想是：当一个新进程进入内在后，首先将它放入第一个队列的末尾，按FCFS原则排队等待高度。当轮到该进程执行时，如能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚为完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS原则等待调度执行，以此类推。

2、实验步骤:

（1）按先来先服务算法将进程排成就绪队列。

（2）检查所有队列是否为空，若空则退出，否则将队首进程调入执行。

（3）检查该运行进程是否运行完毕，若运行完毕，则撤消进程，否则，将该进程插入到下一个逻辑队列的队尾。

（4）是否再插入新的进程,若是则把它放到第一逻辑队列的列尾。

（5）重复步骤（2）、（3）、（4），直到就绪队列为空。

四、流程图

开始

时间片到，进程已占用CPU

时间+1

进程已占用CPU 时间达到所需运行时间？

把进程插入就绪队列尾部

进程完成，撤销改进程

是

否

结束

初始化PCB ，随机生成数据

就绪队列首进程投入运行

就绪队列为空？

是

否

五、程序清单

#include"stdio.h"

#include

#include

#define getpch(type)(type*)malloc(sizeof(type))

#define NULL 0

struct pcb { /* 定义进程控制块PCB */

char name[10];

char state;

int super;

int ntime;

int rtime;

struct pcb* link;

}*ready=NULL,*p;

typedef struct pcb PCB;

////////////////////////////////////////////////////////////// sort()/* 建立对进程进行优化级排列的函数*/

{

PCB *first,*second;

int insert=0;

if((ready==NULL)||((p->super)>(ready->super)))

{

p->link=ready;

ready=p;

}

else

{

first=ready;

second=first->link;

while(second!=NULL)

{

if((p->super)>(second->super))

{

p->link=second;

first->link=p;

second=NULL;

insert=1;

}

else {

first=first->link;

second=second->link;

}

}

if(insert==0) first->link=p;

}

}

////////////////////////////////////////////////////////////// input()/* 建立进程控制块函数*/

{

int i,num;

system("cls");

printf("\n 请输入进程号？");

scanf("%d",&num);

for(i=0;i

{

printf("\n 进程号 No.%d:\n",i);

p=getpch(PCB);

printf("\n 输入进程名:");

scanf("%s",&p->name);

getchar();

printf("\n 输入进程优先数:");

scanf("%d",&p->super);

getchar();

printf("\n 输入进程运行时间:");

scanf("%d",&p->ntime);

printf("\n");

p->rtime=0;p->state='w';

p->link=NULL;

sort();

}

}

///////////////////////////////////////////

int space()

{

int l=0;PCB *pr= ready;

while(pr!=NULL)

{

l++;

pr=pr->link;

}

return(l);

}

////////////////////////////////////////////////

disp(PCB * pr)

{

printf("\n qname\t state \t super \t ndtime \t runtime \n"); printf("%s\t",pr->name);

printf("%c\t",pr->state);

printf("%d\t",pr->super);

printf("%d\t",pr->ntime);

printf("%d\t",pr->rtime);

printf("\n");

}

//////////////////////////////////////////////// check()

{

PCB * pr;

printf("\n **** 当前正在运行的进程是: %s",p->name); disp(p);

pr=ready;

printf("\n **** 当前就绪队列状态为:\n");

while(pr!=NULL)

{

disp(pr);

pr=pr->link;

}

}

////////////////////////////////////////////////// destory()

{

printf("\n 进程[%s] 已完成.\n",p->name);

free(p);

}

////////////////////////////////////////////////// running()

{

(p->rtime)++;

if(p->rtime==p->ntime)

destory();

else

{

(p->super)--;

p->state='w';

sort();

}

}

//////////////////////////////////////////////////// main()

{

int len,h=0;

char ch;

input();

len=space();

while((len!=0)&&(ready!=NULL))

{

ch=getchar();

h++;

printf("\n The execute number:%d \n",h); p=ready;

ready=p->link;

p->link =NULL;

p->state='R';

check();

running();

printf("\n 按任意键继续......");

ch= getchar();

}

printf("\n\n 进程已经完成.\n");

ch=getchar();

}

六、运行结果

六、调试过程小结

在实验中，虽然实验原理很简单，但是在编写代码的过程中遇到了不少的问题，例如在编译的时候，清屏函数会报错。通过这个实验不仅使我对进程的调度算法有了更深的认识，使得理论知识得到的实践，也使我的编程能力得到了进一步提高。

七、思考题

1.分析不同调度算法的调度策略，比较不同调度算法的优缺点，总结它们的适用范围。答：动态有限权算法：动态优先权是指在创建进程时所创建的优先权，会随进程的推进或者

等待时间的增加而改变，以便获得更好的调度性能。处理机为每个进程分配一定的时间片，在就绪队列中，优先权高的进程将优先获得处理机，进程在进去运行完响应的时间片后，如没完成，优先权减1，从新回到就绪队列等待分配处理机。

时间片的轮转法：系统将所有进程排成一个队列，按照先来先服务的原则，对队列首的进程进行处理，每个进程在用完自己的时间片后，从新回到队尾进行排队。每运行一次，进程的需要时间减1，直到就绪队列为空！

2.哪种进程最适合于多级反馈队列调度，是偏重于处理机还是偏重于I/O 型？ 答：处理机。

学号： XXXXXXXX 姓名： XXX 协作者：________

实验__二 _题目__ 作业调度___第 13 周星期__ 四 _

一、实验目的

模拟作业调度的实现，用高级语言编写和雕饰一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解。 二、实验内容和要求

1.为单道批处理系统设计一个作业调度程序

2.模拟批处理多道操作系统的作业调度 三、实验主要仪器设备和材料 硬件环境：IBM-PC 或兼容机

软件环境：C++、C 语言编译环境

四、实验原理及设计方案

1、实验原理

（1）先来先服务算法：是按照作业进入输入井的先后次序来挑选作业，先进入输入井的作业优先被挑选，当系统中现有的尚未分配的资源不能满足先进入输入井的作业时，那么顺序挑选后面的作业。

（2）短作业优先算法：总是按作业要求运行的时间来选择作业，每次挑选要求运行时间短且资源要求能满足的作业先进入主存执行。

（3）高响应比优先调度算法：根据作业要求服务时间和等待时间算出优先权，每次挑选优先权最高的作业先进入主存执行。

要求服务时间

要求服务时间

等待时间优先权+=

2、设计方案

（1）由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作

业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的CPU 时限等因素。

（2）在批处理系统中，要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求，所需要的资源是否得到满足。

3、相关数据结构的说明

/*定义作业块*/

typedef struct jcb{

char name;/*作业名称*/

char state;/*作业状态*/

int ntime;/*所需时间*/

int rtime;/*提交时间*/

int resourse;/*所需资源*/

struct jcb* next;/*节点指针*/

} JCB;

4、程序流程图

（1）先到先服务算法

结束

初始化JCB ，随机生成数据 根据到达时间对JCB 排序 p 指向节点是否为空？ 获取队首指针p ，用以遍历队列 计算当前作业开始运行时刻、周转时间、完成时刻、带权周转时间 累积周转时间和带权周转时

间

移动指针p 指向下一节点 计算平均周转时间及带权平

均周转时间

开始

(2)短作业优先算法

开始

初始化JCB，随机生成数据

根据到达时间对JCB进行排

序，生成初始队列

初始化截止时间，将初始队

列队首调入就绪队列

初始队列和就绪

队列都为空？

遍历完成队列，打印结果

结束

就绪队列为

空？

从就绪队列中挑选要求服务

时间最短的作业调入完成队

列，修改截止时间

从初始队列将满足截止时间

的作业调入就绪队列

（3）高响应比优先算法

开始

初始化JCB，随机生成数据

根据到达时间对JCB进行排

序，生成初始队列

初始化截止时间，将初始队

列队首调入就绪队列

初始队列和就绪

队列都为空？

遍历完成队列，打印结果

结束

就绪队列为

空？

从就绪队列中将满足最高响

应比的作业调入完成队列，

修改截止时间

从初始队列将满足截止时间

的作业调入就绪队列

5、给出程序中源程序名和可执行程序名。

源程序名：os2.c

可执行文件名：os2.exe

6、程序清单

#include

#include

#include

#include

#include

#include

#define NULL 0

#define True 1

#define False 0

/*队列长度*/

#define QueueLength 12

/*随机数范围*/

#define Num 60

typedef int Bool;

/*定义作业块*/

typedef struct jcb{

char name;

char state;

int ntime;/*所需时间*/

int rtime;/*提交时间*/

int resourse;

struct jcb* next;

} JCB;

/*定义作业队列*/

typedef struct{

JCB *head;

JCB *tail;

} Queue;

/*初始化队列*/

void Init(Queue *q){

q->head = NULL;

q->tail = NULL;

}

/*生成n个进程组成的队列，返回作业队列*/ Queue Creat(int n){

Queue q;

JCB *s;

int i;

s = (JCB *)malloc(n * sizeof(JCB));

/*使用时间做种子产生随机数*/

srand((unsigned)time(NULL));

for(i = 0; i < n; i++){

s[i].name = (char)('A'+i);

s[i].state = 'W';

s[i].ntime = rand()%(Num*2)+1;

s[i].rtime = rand()%Num+1;

s[i].resourse = rand()%Num+1;

if(i!=n-1){

s[i].next = s+i+1;

}else{

s[i].next = NULL;

}

}

q.head = s;

q.tail = s+n-1;

return q;

}

/*深度复制队列,返回副本*/

Queue Copy(Queue q1){

Queue q2;

JCB *p ,*temp;

q2.head = NULL;

q2.tail = NULL;

p = q1.head;

while(p != NULL){

temp = (JCB *)malloc(sizeof(JCB));

temp->name = p->name;

temp->ntime = p->ntime;

temp->rtime = p->rtime;

temp->resourse = p->resourse;

temp->state = p->state;

temp->next = NULL;

if(q2.tail == NULL){

q2.head = temp;

q2.tail = temp;

}else{

q2.tail->next = temp;

q2.tail = temp;

}

p = p->next;

}

return q2;

}

/*节点值交换*/

void swap(JCB *p1,JCB *p2){

JCB temp,*next;

if(p1 == NULL || p2 == NULL) return;

/*内存复制实现交换*/

memcpy(&temp,p1,sizeof(JCB));

memcpy(p1,p2,sizeof(JCB));

memcpy(p2,&temp,sizeof(JCB));

/*交换节点*/

next = p1->next;

p1->next = p2->next;

p2->next = next;

}

/*按到达时间对队列进行排序*/

void TimeSort(Queue *q){

JCB *p1,*p2,*small;

if(q->head == NULL) return;

p1 = q->head;

while(p1 != q->tail){

small = p1;

p2 = p1->next;

while(p2 != NULL){

if(p2->rtime < small->rtime){

swap(p2,small);

}

p2 = p2->next;

}

p1 = p1->next;

}

}

/*显示作业队列*/

void display(Queue q){

JCB *p;

int i = 0;

if(q.head == NULL){

printf("队列为空。\n");

}else{

p = q.head;

printf("序号\t名称\t提交\t所需\t资源\t状态\n");

while(p != NULL){

printf("%d\t%c\t%d\t%d\t%d\t%c\n",i++,p->name,p->rtime,p->ntime,p->resourse ,p->state);

p = p->next;

}

}

}

/*查看完成队列*/

void check(Queue q){

JCB *p;

/*lOver前一作业结束时间，nBegin当前作业开始时间*/

int i = 0,lOver = 0,nBegin,turnover,sum_turnover = 0;

float weight,sum_weight = 0;

if(q.head == NULL){

printf("队列为空。\n");

}else{

p = q.head;

printf("序号\t名称\t提交\t所需\t开始\t完成\t周转\t带权\t资源\t响应比\n");

while(p != NULL){

nBegin = lOver > p->rtime ? lOver : p->rtime;

turnover = nBegin + p->ntime - p->rtime;

weight = (float)turnover/(float)p->ntime;

lOver = nBegin + p->ntime;

sum_turnover += turnover;

sum_weight += weight;

printf("%d\t%c\t%d\t%d\t%d\t%d\t%d\t%0.2f\t%d\t%0.2f\n",

i++,p->name,p->rtime,p->ntime,nBegin,lOver,turnover,weight,

p->resourse,(float)turnover/p->ntime);

p = p->next;

}

printf("平均周转时间:%5.2f\n平均带权周转时间:%5.2f\n",(float)sum_turnover/(i+1),sum_weight/(i+1));

}

}

/*装载等待队列,初始队列orig，等待队列wait，截止时间time*/

/*将初始队列中到达时间小于等于截止时间time的作业载入等待队列*/ Bool Load(Queue *orig,Queue *wait,int time){

JCB *p,*pre,*temp;

int flag = 0;

/*判断初始队列是否为空*/

if(orig->head == NULL) {

return False;

}else{

p = orig->head;

pre = orig->head;

}

/*将时间time内的作业载入等待队列*/

while(p != NULL){

/*寄存下一指针，用于恢复指针移动*/

temp = p->next;

if(p->rtime <= time){

flag = 1;

/*剪切*/

/*剪去处的是否为头部*/

if(p == orig->head){

orig->head = p->next;

}else{

pre->next = p->next;

}

/*粘贴*/

/*粘贴处的是否为头部*/

if(wait->head == NULL){

wait->head = p;

}else{

wait->tail->next = p;

}

wait->tail = p;

p->next = NULL;

/*有序时间队列，提高效率*/

}else{

break;

}

/*移动指针*/

pre = p;

p = temp;

}

/*若等待队列为空，且时间范围time内无作业，载入初始队列队首*/ if(wait->head == NULL && !flag){

wait->head = p;

wait->tail = p;

orig->head = p->next;

p->next = NULL;

}

return True;

}

/*将最短作业从wait队列移到completed队列,修改截止时间time*/ void SelectShort(Queue *wait,Queue *completed,int *time){ JCB *p,*small,*pre,*s_pre;

if(wait->head == NULL) return;

p = wait->head;

small = p;

pre = p;

s_pre = p;

/*遍历队列，查找最短作业*/

while(p != NULL){

if(p->ntime < small->ntime){

small = p;

s_pre = pre;

}

pre = p;

p = p->next;

}

/*将最短作业移到完成队列*/

/*判断完成队列是否为空*/

if(completed->head == NULL){

completed->head = small;

}else{

completed->tail->next = small;

}

completed->tail = small;

/*判断移动点是否为头部*/

if(small == wait->head){

wait->head = small->next;

}else{

s_pre->next = small->next;

}

small->next = NULL;

/*修改截止时间*/

if(*time == 0){

*time = small->rtime + small->ntime;