原题：实验二 作业调度---设计测试实验
1.编写并调试一个单道系统的作业调度模拟程序。
调度模型：描述调度模型（可以采用模块化方法并用框图说明）
开始程序，选择调度算法，然后输入作业信息。不论选什么调度算法，作业均按到达先后顺序排队。如果是FCFS模式，每次调度时取出队头作业运行；如果是SJF模式，每次调度遍历队列，找到已到达作业中运行时间最少的，并取出运行；如果是HRRN模式，每次调度遍历队列，找到已到达作业中响应比最大的，并取出运行。作业运行时，计算该作业的运行数据（完成时间，周转时间、带权周转时间等）并打印，且更新这组作业的总周转时间和总带权周转时间。所有作业运行完以后，计算这组作业的平均周转时间和平均带权周转时间。
作业调度算法：分别采用FCFS、SJF、HRRN的调度算法
要求：
1）定义JCB并操作之。
2）描述作业队列。
一个就绪队列，作业按到达先后顺序排队。
3）对每种算法都要求打印每个作业的开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间和带权平均周转时间。比较各种算法的优缺点。
FCFS算法只考虑作业的等待时间，忽视了作业的运行时间，不利于短作业。而SJF算法正好与之相反，只考虑作业运行时间，而忽视了作业的等待时间，不利于长作业。HRRN算法则是既考虑了作业的等待时间，又考虑了作业的运行时间，因此既照顾了短作业，又不致使长作业的等待时间过长，从而改善了处理机调度的性能。不过在某些特殊情况下，HRRN算法的调度结果可能和FCFS算或SJF算法的相同。
编写代码如下：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define getjcb(type) (type*)malloc(sizeof(type))
int n;//作业数
float T1=0,T2=0;//所有作业周转时间、带权周转时间总和
int times=0;//系统时间
struct jcb//作业控制块
{
char name[10];//作业标识符或作业名称
int reachtime;//到达时刻
int starttime;//开始运行时刻
int needtime;//要求服务时间
int finishtime;//作业完成时刻
float cycletime;//作业周转时间
float cltime;//带权周转时间
char state;//作业状态，R即Ready，W即Waiting，F即Finished
struct jcb *next;//指向作业队列下一个作业的JCB
}*ready=NULL,*p,*q;//分别指向队头作业、当前作业，q作为辅助
typedef struct jcb JCB;
void inital()//建立作业控制块队列，按先来先服务模式排队
{
int i;
printf("\n输入作业数:\n");
scanf("%d", &n);
for(i = 0; i<n; i++)
{
p = getjcb(JCB);
printf("\n\n输入作业名:\n");
scanf("%s", p->name);
p->reachtime = i;
printf("\n作业默认到达时间:\n%d\n", i);
printf("\n输入作业要运行的时间:\n");
scanf("%d", &p->needtime);
p->state ='W';
p->next =NULL;
if(ready ==NULL)//如果队空
ready = q = p;//插入到队头
else//否则队非空
{
q->next = p;//插入到队尾
q = p;
}
getchar();//接收信号，继续执行程序
}
}
void disp(JCB *q,int m)//显示作业的周转时间及带权周转时间等
{
printf("\n作业%s正在运行，估计其运行情况：\n",q->name);
printf("开始运行时刻：%d\n",q->starttime);
printf("完成时刻：%d\n",q->finishtime);
printf("周转时间：%f\n",q->cycletime);
printf("带权周转时间：%f\n",q->cltime);
}
void running(JCB *p,int m)//运行作业
{
//先将要运行的作业从队列中分离出来
if(p == ready)//如果要运行作业在队头
{
ready = p->next;//分离队头
p->next =NULL;
}
else//否则从队头逐个查找
{
q = ready;
while(q->next!= p) q=q->next;
q->next = p->next;//找到后分离
}
//计算作业的完成时间,周转时间等等
p->starttime = times;
p->state ='R';
p->finishtime = p->starttime + p->needtime;
p->cycletime = (float)(p->finishtime - p->reachtime);
p->cltime = (float)(p->cycletime / p->needtime);
T1 += p->cycletime;
T2 += p->cltime;
disp(p, m);//显示计算数据
//作业完成，更新系统时间，删除作业
times += p->needtime;
p->state ='F';
printf("\n%s has been finished!\n", p->name);
free(p);
getchar();//接收信号以继续运行程序
}
void final()//所有作业运行完后打印平均周转时间,平均带权周转时间
{
float s,t;
t=T1/n;
s=T2/n;
printf("\n\n作业已经全部完成!\n");
printf("\n%d个作业的平均周转时间是：%f",n,t);
printf("\n%d个作业的平均带权周转时间是：%f\n",n,s);
}
void sjf(int m)//最短作业优先模式
{
JCB *min;//指向最短作业
int i,iden;
system("cls");//清屏
inital();//建立作业控制块队列，并初始化
for(i=0;i<n;i++)
{
p=min=ready;//从队头开始
iden=1;
do{//寻找最短作业
if(p->state=='W'&&p->reachtime<=times)
if(iden)//找到第一个在此刻或之前到达的待运行作业
{
min=p;
iden=0;
}
else if(p->needtime<min->needtime) min=p;
p=p->next;
}while(p!=NULL);
if(iden)//此刻之前没有作业到达
{
i--;//纠正已完成作业数量
times++;//更新系统时间
if(times>100)//判断等待作业到达时间是否过长
{
printf("\nruntime is too long … error\n");
getchar();
}
}
else//否则运行作业
{
running(min, m);
}
}
final();//所有作业运行完后查看平均周转时间、平均带权周转时间
}
void fcfs(int m)//先来先服务模式
{
int i, iden;
system("cls");//清屏
inital();//建立作业控制块队列，并初始化
for(i = 0; i<n; i++)
{
p = ready;//从队头开始
iden = 1;
do{
//找到第一个在此刻或之前到达的待运行作业
if(p->state =='W'&&p->reachtime <= times) iden = 0;
//没找到则继续找
if(iden) p = p->next;
}while(p!=NULL&&iden);//直到找到为止或者找到队尾
if(iden)//没有找到一个在此刻之前到达的待运行作业
{
i--;//纠正已完成作业数
printf("\n没有满足要求的进程,需等待\n");
times++;//更新系统时间
if(times>100)//判断等待时间是否过长
{
printf("\n时间过长！\n");
}
}
else//否则运行作业
{
running(p, m);
}
}
final();//所有作业运行完后查看平均周转时间、平均带权周转时间
}
void hrrn(int m)//最高响应比优先模式
{
JCB *max;//指向响应比最高的作业
int i,iden;
float a,b;
system("cls");
inital();
for(int i=0;i<n;i++)
{
p=max=ready;
iden=1;
do{//寻找最高响应比作业
if(p->state=='W'&&p->reachtime<=times)
if(iden)//找到第一个在此刻或之前到达的待运行作业
{
max=p;
iden=0;
//计算响应比
a=times-max->reachtime+max->needtime;
a/=max->needtime;
}
else {
//计算响应比
b=times-p->reachtime+p->needtime;
b/=p->needtime;
if(a<b){//更新最大响应比
a=b;
max=p;
}
}
p=p->next;
}while(p!=NULL);
if(iden)//此刻之前没有作业到达
{
i--;//纠正已完成作业数量
times++;//更新系统时间
if(times>100)//判断等待作业到达时间是否过长
{
printf("\nruntime is too long … error\n");
getchar();
}
}
else//否则运行作业
{
running(max, m);
}
}
final();
}
void menu()//提供服务菜单
{
int m;//存储用户选择
system("cls");//清屏
printf("\n\n\t\t*********************************************\t\t\n");
printf("\t\t\t\t作业调度演示\n");
printf("\t\t*********************************************\t\t\n");
printf("\n\n\n\t\t\t1.先来先服务算法.");
printf("\n\t\t\t2.最短作业优先算法.");
printf("\n\t\t\t3.最高响应比优先算法.");
printf("\n\t\t\t0.退出程序.");
printf("\n\n\t\t\t\t选择所要操作:");
scanf("%d", &m);//接收用户选择
switch (m)//进行服务
{
case 1:
fcfs(m);
getchar();
system("cls");
break;
case 2:
sjf(m);
getchar();
system("cls");
break;
case 3:
hrrn(m);
getchar();
system("cls");
break;
case 0:
system("cls");
break;
default:
printf("选择错误,重新选择.\n");
getchar();
system("cls");
menu();
}
}
int main()
{
menu();//打开菜单，提供服务
system("pause");//终端窗口停靠
return 0;
}2.编写并调试一个多道系统的作业调度模拟程序。
调度模型：描述多道调度模型（可以采用模块化方法并用框图说明）
作业按到达先后顺序排队，调度时取出后备队列队头，一次取完作业所有需要的资源，如果不能满足作业需求，作业将被置阻塞态，放回到队尾，然后取出后备队列队头并判断是否能运行，重复该过程直到找到能运行的作业，如果找不到，该CPU将处于空闲状态。
作业调度算法：FCFS
要求：
1）定义JCB并操作之。
2）描述作业队列。
一个后备队列，初始时按FCFS模式排队。
3）定义多道系统中的各种资源种类及数量，调度作业时必须考虑到每个作业的资源需求。
双核CPU，3种资源，总数分别为10、5、7。
设计代码如下：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define getjcb(type) (type*)malloc(sizeof(type))
int n;//作业数
float T1 = 0, T2 = 0;//所有作业周转时间、带权周转时间总和
int times[2] = { 0,0 };//双核系统的时间
int available[3] = { 10,5,7 };//系统资源总数
struct jcb//作业控制块
{
char name[10];//作业标识符或作业名称
int reachtime;//到达时刻
int starttime;//开始运行时刻
int needtime;//要求服务时间
int finishtime;//作业完成时刻
float cycletime;//作业周转时间
float cltime;//带权周转时间
char state;//作业状态，R即Ready，W即Waiting，B即Block
int need[3];//作业对系统资源的需求
int CPU;
struct jcb* next;//指向作业队列下一个作业的JCB
}*ready = NULL, * p, * q[2];//分别指向队头作业、当前作业
//核1使用q[0]，核2使用q[1]
typedef struct jcb JCB;
void insert()/*按先来后到顺序创建就绪队列*/
{
JCB* first, * second;
if (ready == NULL)/*若队空*/
{
//插入到队首
p->next = ready;
ready = p;
}
else/*否则应插入到队尾*/
{
first = ready;
second = first->next;
while (second != NULL)//寻找队尾
{
first = second;
second = second->next;
}
//插入
first->next = p;
}
}
void inital()//初始化函数
{
int i, j;
printf("\n输入作业数:\n");
scanf("%d", &n);
for (i = 0; i < n; i++)
{
p = getjcb(JCB);
printf("\n\n输入第%d个作业名:\n", i + 1);
scanf("%s", p->name);
p->reachtime = i;
printf("\n第%d个作业默认到达时间:\n%d\n", i + 1, i);
printf("\n输入第%d个作业要运行的时间:\n", i + 1);
scanf("%d", &p->needtime);
for (j = 0; j < 3; j++)
{
printf("\n输入作业对第%d类资源需求：", j + 1);
scanf("%d", &p->need[j]);
if (p->need[j] > available[j]) {
printf("作业资源需求超出系统支持范围！无法进行调度。");
exit(0);
}
}
p->state = 'W';
p->next = NULL;
insert();
getchar();//接收信号，继续执行程序
}
}
void finish(JCB* q)//显示作业的周转时间及带权周转时间等
{
printf("\n作业%s正在运行，估计其运行情况：\n", q->name);
printf("到达时刻：%d\n", q->reachtime);
printf("开始运行时刻：%d\n", q->starttime);
printf("完成时刻：%d\n", q->finishtime);
printf("周转时间：%f\n", q->cycletime);
printf("带权周转时间：%f\n", q->cltime);
}
void disp(JCB* pr)//显示后备队列作业
{
printf("\nname state reachtime needtime need\n");
printf("|%s\t", pr->name);
printf("|%c\t", pr->state);
printf("|%d\t", pr->reachtime);
printf("|%d\t", pr->needtime);
printf("|%d %d %d", pr->need[0], pr->need[1], pr->need[2]);
printf("\n");
}
void check()
{
JCB* pr;
pr = ready;
printf("\n ****当前后备队列状态为:\n");/*显示后备队列作业*/
while (pr != NULL) {
disp(pr);
pr = pr->next;
}
}
int space()
{
if (ready == NULL) return 0;
if (ready->next == NULL) return 1;
int sum = 0;
JCB* pr;
pr = ready;
while (pr != NULL)
{
sum++;
pr = pr->next;
}
return sum;
}
void running(int m)//m+1号CPU运行作业
{
if (ready == NULL) return;
int sum = space(), num = 0, flag = 1;
do {
//先将要运行的作业从队列中分离出来
q[m] = ready;
ready = q[m]->next;//分离队头
q[m]->next = NULL;
num++;
//判断系统资源是否充足
if (q[m]->need[0] <= available[0] &&
q[m]->need[1] <= available[1] &&
q[m]->need[2] <= available[2]) {
flag = 0;
break;
}
else {
q[m]->CPU = m;
q[m]->state = 'B';
p = q[m];
insert();
}
} while (num != sum);
if (flag) {
printf("\n当前没有可运行的作业！\n");
printf("核%d空闲！", m + 1);
q[m] = NULL;
if(m){
times[1]=times[0];
}
else times[0]=times[1];
return;
}
//给作业分配资源
available[0] -= q[m]->need[0];
available[1] -= q[m]->need[1];
available[2] -= q[m]->need[2];
//计算作业的完成时间,周转时间等等
if (q[m]->state == 'B') {//如果作业之前被阻塞
times[m] = q[m]->starttime = times[q[m]->CPU];
}
else q[m]->starttime = times[m];
if (q[m]->reachtime > times[m]) {//如果作业还没到达
times[m] = q[m]->starttime= q[m]->reachtime;
}
else q[m]->starttime = times[m];
q[m]->state = 'R';
q[m]->finishtime = q[m]->starttime + q[m]->needtime;
q[m]->cycletime = (float)(q[m]->finishtime - q[m]->reachtime);
q[m]->cltime = (float)(q[m]->cycletime / q[m]->needtime);
T1 += q[m]->cycletime;
T2 += q[m]->cltime;
times[m]+=q[m]->needtime;//更新系统时间
printf("\n核%d忙碌！", m + 1);
finish(q[m]);//显示计算数据
getchar();//接收信号以继续运行程序
}
void distory(int m)
{
if (q[m] == NULL) return;
//作业完成，归还资源，删除作业
printf("\n%s has been finished!\n", q[m]->name);
available[0] += q[m]->need[0];
available[1] += q[m]->need[1];
available[2] += q[m]->need[2];
free(q[m]);
q[m] = NULL;
}
void final()//所有作业运行完后打印平均周转时间,平均带权周转时间
{
float s, t;
t = T1 / n;
s = T2 / n;
printf("\n\n作业已经全部完成!\n");
printf("\n%d个作业的平均周转时间是：%f", n, t);
printf("\n%d个作业的平均带权周转时间是：%f\n", n, s);
}
void fcfs()//先来先服务模式
{
system("cls");//清屏
inital();//建立作业控制块队列，并初始化
running(0);
running(1);
distory(0);
distory(1);
check();
while (ready != NULL)
{
if (times[0] <= times[1]) {
running(0);
running(1);
distory(0);
distory(1);
}
else {
running(1);
running(0);
distory(1);
distory(0);
}
check();
}
final();//所有作业运行完后查看平均周转时间、平均带权周转时间
}
int main()
{
q[0] = q[1] = NULL;
fcfs();//进行双核下的FCFS作业调度
system("pause");//终端窗口停靠
return 0;
}3.编写并调试一个多道程序系统的作业调度模拟程序。
调度模型：描述多道调度模型（可以采用模块化方法并用框图说明）
输入作业信息，为作业创建JCB，并按优先级规则在就绪队列里排好队。调度时先检查阻塞队列是否为空，如果为空则从就绪队列取出队首，判断系统资源是否足够，如果足够就运行，否则将其置为阻塞态，插入阻塞队列队尾，并取出就绪队列队头，判断系统资源是否足够，重复此操作直到找到可以运行的作业，如果找不到该CPU就会处于空闲。如果阻塞队列不为空，取出阻塞队列队首，判断系统资源是否足够，如果足够就运行，否则将其插回阻塞队列队尾，重复此过程直到找到可以运行的作业，如果找不到，就到就绪队列找，如果就绪队列里也找不到，该CPU将处于空闲。
作业调度算法：采用基于优先级的作业调度。
要求：
1）自己设计实现一个确定优先级的方法。
作业紧迫程度分3个等级，3为危急，2为一般，1为可推延。作业按紧迫程度降序排队，相同紧迫度的作业之间按FCFS模式排队。——此即优先级规则。
2）定义JCB并操作之。
3）描述作业队列。
一个就绪队列，一个阻塞队列，就绪队列按优先级规则排序，阻塞队列按FCFS模式排队。
4）定义多道系统中的各种资源种类及数量，调度作业时必须考虑到每个作业的资源需求。
双核CPU，优先使用核2，三种系统资源，总数分别为10,5,7。
代码背景同第2题。编写代码如下：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define getjcb(type) (type*)malloc(sizeof(type))
int n;//作业数
float T1 = 0, T2 = 0;//所有作业周转时间、带权周转时间总和
int times[2] = { 0,0 };//双核系统的时间
int available[3] = { 10,5,7 };//系统资源总数
struct jcb//作业控制块
{
char name[10];//作业标识符或作业名称
int reachtime;//到达时刻
int starttime;//开始运行时刻
int needtime;//要求服务时间
int finishtime;//作业完成时刻
float cycletime;//作业周转时间
float cltime;//带权周转时间
char state;//作业状态，R即Ready，W即Waiting，B即Block
int need[3];//作业对系统资源的需求
int CPU;//被何cpu投入阻塞队列
int sign;//紧急程度
struct jcb* next;//指向作业队列下一个作业的JCB
}*ready[2], * p[2], * q[2];//分别指向队头作业、当前作业
//对于ready和p，0表示就绪队列，1表示阻塞队列，对于q，0表示核1,1表示核2
typedef struct jcb JCB;
void sort(int m)/*对作业进行优先级排序函数*/
{
JCB* first, * second;
if (m) {//m=1,阻塞队列
if (ready[m] == NULL) {
p[m]->next = ready[m];
ready[m] = p[m];
}
else {
first = ready[m];
second = first->next;
while (second != NULL) {
first = second;
second = first->next;
}
first->next = p[m];
}
return;
}
int insert = 0;//表示插入状态
if ((ready[m] == NULL) || ((p[m]->sign) > (ready[m]->sign)))/*若队空或插入作业优先数比当前队首大*/
{
//插入到队首
p[m]->next = ready[m];
ready[m] = p[m];
}
else /*作业比较优先级，插入适当的位置中*/
{
first = ready[m];
second = first->next;
while (second != NULL)//未到达队尾或未成功插入
{
if ((p[m]->sign) > (second->sign))/*若插入作业比当前进程优先级大*/
{
/*插入到当前作业前面*/
p[m]->next = second;
first->next = p[m];
second = NULL; //提前终止循环
insert = 1; //插入成功
}
else//与下一个作业比较
{
first = second;
second = second->next;
}
}
//到达队尾仍未成功插入，说明插入作业优先级最低
if (insert == 0) first->next = p[m];//插入到队尾
}
}
void inital()//初始化函数
{
int i, j;
printf("\n输入作业数:\n");
scanf("%d", &n);
for (i = 0; i < n; i++)
{
p[0] = getjcb(JCB);
printf("\n\n输入第%d个作业名:\n", i + 1);
scanf("%s", p[0]->name);
p[0]->reachtime = i/2;//同一时刻可以到达两道作业
printf("\n第%d个作业默认到达时间:\n%d\n", i + 1, p[0]->reachtime);
printf("\n输入第%d个作业要运行的时间:\n", i + 1);
scanf("%d", &p[0]->needtime);
printf("\n输入第%d个作业的紧迫程度：\n", i + 1);
scanf("%d", &p[0]->sign);
for (j = 0; j < 3; j++)
{
printf("\n输入作业对第%d类资源需求：", j + 1);
scanf("%d", &p[0]->need[j]);
if (p[0]->need[j] > available[j]) {
printf("作业资源需求超出系统支持范围！无法进行调度。");
exit(0);
}
}
p[0]->state = 'W';
p[0]->next = NULL;
sort(0);
getchar();//接收信号，继续执行程序
}
}
void finish(JCB* q)//显示作业的周转时间及带权周转时间等
{
printf("\n作业%s正在运行，估计其运行情况：\n", q->name);
printf("到达时刻：%d\n", q->reachtime);
printf("开始运行时刻：%d\n", q->starttime);
printf("完成时刻：%d\n", q->finishtime);
printf("周转时间：%f\n", q->cycletime);
printf("带权周转时间：%f\n", q->cltime);
}
void disp(JCB* pr)//显示队列中的作业
{
printf("\nname state reachtime needtime need sign\n");
printf("|%s\t", pr->name);
printf("|%c\t", pr->state);
printf("|%d\t", pr->reachtime);
printf("|%d\t", pr->needtime);
printf("|%d %d %d", pr->need[0], pr->need[1], pr->need[2]);
printf("|%d\t", pr->sign);
printf("\n");
}
void check()
{
JCB* pr;
pr = ready[0];
printf("\n ****当前就绪队列状态为:\n");/*显示就绪队列作业*/
while (pr != NULL) {
disp(pr);
pr = pr->next;
}
printf("\n ****当前阻塞队列状态为:\n");/*显示就绪队列作业*/
pr = ready[1];
while (pr != NULL) {
disp(pr);
pr = pr->next;
}
}
int space(int m)
{
if (ready[m] == NULL) return 0;
if (ready[m]->next == NULL) return 1;
int sum = 0;
JCB* pr;
pr = ready[m];
while (pr != NULL)
{
sum++;
pr = pr->next;
}
return sum;
}
void running(int m)//m+1号CPU运行作业
{
if (ready[0] == NULL && ready[1] == NULL) return;
int sum_R = space(0), sum_B=space(1),num = 0, flag = 1;
if (sum_B) {//阻塞队列非空
do {
//先将要运行的作业从队列中分离出来
q[m] = ready[1];
ready[1] = q[m]->next;//分离队头
q[m]->next = NULL;
num++;
//判断系统资源是否充足
if (q[m]->need[0] <= available[0] &&
q[m]->need[1] <= available[1] &&
q[m]->need[2] <= available[2]) {
flag = 0;
break;
}
else {
q[m]->CPU = m;
q[m]->state = 'B';
p[1] = q[m];
sort(1);
}
} while (num != sum_B);
if (flag&&sum_R) {//阻塞队列没有可运行作业，从就绪队列中找
num = 0;
do {
//先将要运行的作业从队列中分离出来
q[m] = ready[0];
ready[0] = q[m]->next;//分离队头
q[m]->next = NULL;
num++;
//判断系统资源是否充足
if (q[m]->need[0] <= available[0] &&
q[m]->need[1] <= available[1] &&
q[m]->need[2] <= available[2]) {
flag = 0;
break;
}
else {
q[m]->CPU = m;
q[m]->state = 'B';
p[1] = q[m];
sort(1);
}
} while (num != sum_R);
}
if (flag) {
printf("\n当前没有可运行的作业！\n");
printf("核%d空闲！", m + 1);
q[m] = NULL;
if (m) {
times[1] = times[0];
}
else times[0] = times[1];
return;
}
}
else if (sum_R) {//阻塞队列为空，就绪队列不为空
do {
//先将要运行的作业从队列中分离出来
q[m] = ready[0];
ready[0] = q[m]->next;//分离队头
q[m]->next = NULL;
num++;
//判断系统资源是否充足
if (q[m]->need[0] <= available[0] &&
q[m]->need[1] <= available[1] &&
q[m]->need[2] <= available[2]) {
flag = 0;
break;
}
else {
q[m]->CPU = m;
q[m]->state = 'B';
p[1] = q[m];
sort(1);
}
} while (num != sum_R);
if (flag) {
printf("\n当前没有可运行的作业！\n");
printf("核%d空闲！", m + 1);
q[m] = NULL;
if (m) {
times[1] = times[0];
}
else times[0] = times[1];
return;
}
}
//给作业分配资源
available[0] -= q[m]->need[0];
available[1] -= q[m]->need[1];
available[2] -= q[m]->need[2];
//计算作业的完成时间,周转时间等等
if (q[m]->reachtime > times[m]) {//如果作业还没到达
times[m] = q[m]->starttime= q[m]->reachtime;
}
else q[m]->starttime = times[m];
q[m]->state = 'R';
q[m]->finishtime = q[m]->starttime + q[m]->needtime;
q[m]->cycletime = (float)(q[m]->finishtime - q[m]->reachtime);
q[m]->cltime = (float)(q[m]->cycletime / q[m]->needtime);
T1 += q[m]->cycletime;
T2 += q[m]->cltime;
times[m] += q[m]->needtime;//更新系统时间
printf("\n核%d忙碌！", m + 1);
finish(q[m]);//显示计算数据
getchar();//接收信号以继续运行程序
}
void distory(int m)
{
if (q[m] == NULL) return;
//作业完成，归还资源，删除作业
printf("\n%s has been finished!\n", q[m]->name);
available[0] += q[m]->need[0];
available[1] += q[m]->need[1];
available[2] += q[m]->need[2];
free(q[m]);
q[m] = NULL;
}
void final()//所有作业运行完后打印平均周转时间,平均带权周转时间
{
float s, t;
t = T1 / n;
s = T2 / n;
printf("\n\n作业已经全部完成!\n");
printf("\n%d个作业的平均周转时间是：%f", n, t);
printf("\n%d个作业的平均带权周转时间是：%f\n", n, s);
}
void control()//基于优先级模式
{
system("cls");//清屏
inital();//建立作业控制块队列，并初始化
running(0);
running(1);
distory(0);
distory(1);
check();
while (ready[0] != NULL || ready[1]!= NULL)
{
if (times[0] < times[1]) {
running(0);
running(1);
distory(0);
distory(1);
}
else {
running(1);
running(0);
distory(1);
distory(0);
}
check();
}
final();//所有作业运行完后查看平均周转时间、平均带权周转时间
}
int main()
{
q[0] = q[1] = NULL;
p[0] = p[1] = NULL;
ready[0] = ready[1] = NULL;
control();//进行双核下的基于优先级作业调度
system("pause");//终端窗口停靠
return 0;
}
1685
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
