求一份儿C语言优先级调度算法要求如下
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了求一份儿C语言优先级调度算法要求如下相关的知识，希望对你有一定的参考价值。
1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：
进程名
指针
要求运行时间
优先数
状态
其中，进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。
指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。
要求运行时间——假设进程需要运行的单位时间数。
优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。
状态——可假设有两种状态，“就绪”状态和“结束”状态。五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。
(2) 在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。
(3) 为了调度方便，把五个进程按给定的优先数从大到小连成队列。用一单元指出队首进程，用指针指出队列的连接情况。例
(4) 处理器调度总是选队首进程运行。采用动态改变优先数的办法，进程每运行一次优先数就减“1”。由于本实习是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：
优先数-1
要求运行时间-1
来模拟进程的一次运行。
提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。在这里省去了这些工作。
(5) 进程运行一次后，若要求运行时间0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间=0，则把它的状态修改成“结束”（E），且退出队列。
(6) 若“就绪”状态的进程队列不为空，则重复上面（4）和（5）的步骤，直到所有进程都成为“结束”状态。
(7) 在所设计的程序中应有显示或打印语句，能显示或打印每次被选中进程的进程名以及运行一次后进程队列的变化。
(8) 为五个进程任意确定一组“优先数”和“要求运行时间”，启动所设计的处理器调度程序，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。
#define n 10 /*假定系统中可容纳的作业数量为n*/
typedef struct jcb
char name[4]; /*作业名*/
int length; /*作业长度，所需主存大小*/
int printer; /*作业执行所需打印机的数量*/
int tape; /*作业执行所需磁带机的数量*/
int runtime; /*作业估计执行时间*/
int waittime; /*作业在系统中的等待时间*/
int next; /*指向下一个作业控制块的指针*/
JCB; /*作业控制块类型定义*/
int head; /*作业队列头指针定义*/
int tape,printer;
long memory;
JCB jobtable[n]; /*作业表*/
int jobcount=0; /*系统内现有作业数量*/
shedule( )
/*作业调度函数*/
float xk,k;
int p,q,s,t;
do
p=head;
q=s=-1;
k=0;
while(p!=-1)
if(jobtable[p].length<=memory&&jobtable[p].tape<=tape&&jobtable[p].printer<=printer)
/*系统可用资源是否满足作业需求*/
xk=(float)(jobtable[p].waittime)/jobtable[p].runtime;
if(q==0||xk>k) /*满足条件的第一个作业或者作业q的响应比小于作业p的响应比*/
k=xk; /*记录响应比*/
q=p;
t=s;
/*if*/
/*if*/
s=p;
p=jobtable[p].next; /*指针p后移*/
/*while*/
if(q!=-1)
if(t==-1) /*是作业队列的第一个*/
head=jobtable[head].next;
else
jobtable[t].next=jobtable[q].next;
/*为作业q分配资源：分配主存空间；分配磁带机;分配打印机*/
memory=memory-jobtable[q].length;
tape=tape-jobtable[q].tape;
printer=printer-jobtable[q].printer;
printf("选中作业的作业名：%s\n",jobtable[q].name);
while(q!=-1);
/*作业调度函数结束*/
main( )
char name[4];
int size,tcount,pcount,wtime,rtime;
int p;
/*系统数据初始化*/
memory=65536;
tape=4;
printer=2;
head=-1;
printf("输入作业相关数据(以作业大小为负数停止输入)：\n");
/*输入数据，建立作业队列*/
printf("输入作业名、作业大小、磁带机数、打印机数、等待时间、估计执行时间\n");
scanf("%s%d%d %d %d %d",name,&size,&tcount,&pcount,&wtime,&rtime);
while(size!=-1)
/*创建JCB*/
if(jobcount<n)p=jobcount;
else printf("无法再创建作业\n");
break;
jobcount++;
/*填写该作业相关内容*/
strcpy(jobtable[p].name,name);
jobtable[p].length=size;
jobtable[p].printer=pcount;
jobtable[p].tape=tcount;
jobtable[p].runtime=rtime;
jobtable[p].waittime=wtime;
/*挂入作业队列队首*/
jobtable[p].next=head;
head=p;
/* 输入一个作业数据*/
printf("输入作业名、作业大小、磁带机数、打印机数、等待时间、估计执行时间\n");
scanf("%s%d%d%d%d%d",name,&size,&tcount,&pcount,&wtime,&rtime);
/*while*/
shedule( ); /*进行作业调度*/
/*main( )函数结束*/ 参考技术A 可以利用堆排序或置换-选择排序实现优先级队列和优先级调度算法本回答被提问者采纳
操作系统实验1：处理机调度
注：本文记录 WHUT-计算机学院-操作系统 课程 实验1：处理机调度
纸上得来终觉浅，觉知此事需躬行！
１、实验内容：
•实验预备：掌握处理机调度的相关内容，对进程调度算法有深入的理解
•实验内容：模拟实现进程调度功能
•具体要求：
- –任选一种计算机高级语言编程实现
- –选择1~2种进程调度算法，例如：先来先服务、短进程优先、最高响应比优先、时间片轮转、优先级法等
- –能够输入进程的基本信息，如进程名、到达时间和预估运行时间等
- –根据选择的调度算法显示进程调度顺序
- –显示完成调度后每个进程的开始时间、完成时间、周转时间、带权周转时间
- –计算平均周转时间和平均带权周转时间
2、运行结果：
2.1 测试用例：
2.2 运行截图：
3、程序源码：
本次实验难度不大，代码建议参考使用，不建议完全Ctrl+C and Ctrl+V！！！
另：代码有不严谨之处，你能发现吗？
#include <iostream>
#include <iomanip>
using namespace std;
//其中i为作业个数，j为作业列数；
int n = 4;//作业数
//平均周转时间
double T=0;
//带权周转时间
double W = 0;
/*定义作业保存数组，第1—n列分别为：作业号、提交时间、估计运行时间、优先数（0行、0列不用）
作业号 提交时间 估计运行时间 优先数
1 10.0 2.0 2
2 10.2 1.0 4
3 10.4 0.5 1
4 10.5 0.3 3
*/
double work[5][5] = 0, 0, 0, 0, 0,
0, 1, 10.0, 2.0, 2,
0, 2, 10.2, 1.0, 4,
0, 3, 10.4, 0.5, 1,
0, 4, 10.5, 0.3, 3;
//先来先服务算法使用数组
//1:作业号 2：提交时间 3：运行时间 4：开始时间 5：终止时间 6：周转时间 7：带权周转时间 8：执行顺序
double FCFS[5][9];
//短进程优先法数据保存数组；
//1:作业号 2：提交时间 3：运行时间 4：开始时间 5：终止时间 6：周转时间 7：带权周转时间 8：执行顺序
//double SJF[5][9];
//与FCFS共用一套数组
//优先级算法使用数组
//1:作业号 2：提交时间 3：运行时间 4：优先级 5：开始时间 6：终止时间 7：周转时间 8：带权周转时间 9：执行顺序
double YXJ[5][10];
//HRN算法使用数组
void change(double &a,double &b)
double temp = a;
a = b;
b = temp;
//初始化，按照提交时间（第 2 列）顺序，进行排序操作
int InitFCFS()
//排序
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n - i; j++)
if (work[j][2] > work[j + 1][2])
change(work[j][1], work[j + 1][1]); //作业号 交换
change(work[j][2], work[j + 1][2]); //提交时间 交换
change(work[j][3], work[j + 1][3]); //运行时间 交换
change(work[j][4], work[j + 1][4]); //优先数 交换
//赋值
for (int i = 1; i <= n; i++)
FCFS[i][1] = work[i][1]; //更新 作业号
FCFS[i][2] = work[i][2]; //更新 提交时间
FCFS[i][3] = work[i][3]; //更新 运行时间 其中优先数在FCFS中用不到
return 1;
//初始化，按照运行时间（第 3 列）顺序，其中最早加入的作业始终置于第一位
int InitSJF()
//寻找提交时间最早的一个,并放在第一位
double early = 100000;
int flag = 0;
for (int i = 1; i <= n; i++)
if (early > work[i][2])
early = work[i][2];
flag = i;
//更新Work表中数据，如果首项不为最早提交的则需要交换，否则不用交换
if (flag != 1)
change(work[1][1], work[flag][1]); //作业号 交换
change(work[1][2], work[flag][2]); //提交时间 交换
change(work[1][3], work[flag][3]); //运行时间 交换
change(work[1][4], work[flag][4]); //优先数 交换
//排序,其中第一位不需要考虑了,直接从第二位2开始
for (int i = 2; i <= n; i++)
for (int j = 2; j <= n - i+1; j++)
if (work[j][3] > work[j + 1][3])
change(work[j][1], work[j + 1][1]); //作业号 交换
change(work[j][2], work[j + 1][2]); //提交时间 交换
change(work[j][3], work[j + 1][3]); //运行时间 交换
change(work[j][4], work[j + 1][4]); //优先数 交换
//赋值
for (int i = 1; i <= n; i++)
FCFS[i][1] = work[i][1]; //更新 作业号
FCFS[i][2] = work[i][2]; //更新 提交时间
FCFS[i][3] = work[i][3]; //更新 运行时间 其中优先数在FCFS中用不到
return 1;
//只要对FCFS或者SJF的前三列基本排序完成，那么后边操作相同，合并算法
void FCFS_SJF()
//置零
T = 0;
W = 0;
for (int i = 1; i <= n; i++)
//如果是第一个任务
if (i == 1)
FCFS[i][4] = FCFS[i][2];//第一个任务：开始时间=提交时间
else
//如果当前任务提交时间比最后一个任务结束时间晚
FCFS[i][4] = FCFS[i - 1][5];//第二个任务以后：开始时间=上一个任务的终止时间
FCFS[i][5] = FCFS[i][4] + FCFS[i][3];//终止时间=开始时间+运行时间
FCFS[i][6] = FCFS[i][5] - FCFS[i][2];//周转时间=终止时间-提交时间
FCFS[i][7] = FCFS[i][6] / FCFS[i][3];//带权周转时间=周转时间÷运行时间
FCFS[i][8] = i;//初始化已经对程序执行顺序进行排序，则第i个程序的执行顺序即为i
//计算
for (int i = 1; i <= n; i++)
T += FCFS[i][6];
W += FCFS[i][7];
T /= n;
W /= n;
int InitYXJ()
//寻找提交时间最早的一个,并放在第一位
double early = 100000;
int flag = 0;
for (int i = 1; i <= n; i++)
if (early > work[i][2])
early = work[i][2];
flag = i;
//更新Work表中数据，如果首项不为最早提交的则需要交换，否则不用交换
if (flag != 1)
change(work[1][1], work[flag][1]); //作业号 交换
change(work[1][2], work[flag][2]); //提交时间 交换
change(work[1][3], work[flag][3]); //运行时间 交换
change(work[1][4], work[flag][4]); //优先数 交换
//排序,其中第一位不需要考虑了,直接从第二位2开始
for (int i = 2; i <= n; i++)
for (int j = 2; j <= n - i + 1; j++)
if (work[j][4] > work[j + 1][4])
change(work[j][1], work[j + 1][1]); //作业号 交换
change(work[j][2], work[j + 1][2]); //提交时间 交换
change(work[j][3], work[j + 1][3]); //运行时间 交换
change(work[j][4], work[j + 1][4]); //优先数 交换
//赋值
for (int i = 1; i <= n; i++)
YXJ[i][1] = work[i][1]; //更新 作业号
YXJ[i][2] = work[i][2]; //更新 提交时间
YXJ[i][3] = work[i][3]; //更新 运行时间
YXJ[i][4] = work[i][4]; //更新 优先级
return 1;
void theFCFS()
InitFCFS();//初始化FCFS数组前三列
FCFS_SJF();
void theSJF()
InitSJF();//初始化SJF数组前三列
FCFS_SJF();
;
int InitHRN()
return 1;
void theYXJ()
//置零
InitYXJ();
T = 0;
W = 0;
for (int i = 1; i <= n; i++)
//如果是第一个任务
if (i == 1)
YXJ[i][5] = YXJ[i][2];//第一个任务：开始时间=提交时间
else
YXJ[i][5] = YXJ[i - 1][6];//第二个任务以后：开始时间=上一个任务的终止时间
YXJ[i][6] = YXJ[i][5] + YXJ[i][3];//终止时间=开始时间+运行时间
YXJ[i][7] = YXJ[i][6] - YXJ[i][2];//周转时间=终止时间-提交时间
YXJ[i][8] = YXJ[i][7] / YXJ[i][3];//带权周转时间=周转时间÷运行时间
YXJ[i][9] = i;//初始化已经对程序执行顺序进行排序，则第i个程序的执行顺序即为i
//计算
for (int i = 1; i <= n; i++)
T += YXJ[i][7];
W += YXJ[i][8];
T /= n;
W /= n;
int main()
cout << "请按照以下格式输入作业信息表：" << endl;
cout << "作业号 提交时间 运行时间 优先数" << endl;
for (int i = 1; i <= n; i++)
cin >> work[i][1] >> work[i][2] >> work[i][3] >> work[i][4];
cout << "输入完毕！" << endl << endl;
while (1)
cout << "1、先来先服务\\n2、最短作业优先\\n3、优先级法\\n0、退出" << endl;
int choice;
cout << "请选择使用的处理机算法：";
cin >> choice;
switch (choice)
case 1:
cout << "使用先来先服务算法结果如下：" << endl;
theFCFS();
cout << "作业号\\t\\t提交时间\\t运行时间\\t开始时间\\t终止时间\\t周转时间\\t带权周转时间\\t执行顺序" << endl;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 8; j++)
cout << FCFS[i][j] << "\\t\\t";
cout << endl;
cout << "平均周转时间：" << T << endl;
cout << "带权周转时间：" << W << endl<<endl;
break;
case 2:
theSJF();
cout << "使用短作业优先算法结果如下：" << endl;
cout << "作业号\\t\\t提交时间\\t运行时间\\t开始时间\\t终止时间\\t周转时间\\t带权周转时间\\t执行顺序" << endl;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 8; j++)
cout << FCFS[i][j] << "\\t\\t";
cout << endl;
cout << "平均周转时间：" << T << endl;
cout << "带权周转时间：" << W << endl<<endl;
break;
case 3:
theYXJ();
cout << "使用优先级算法结果如下：" << endl;
cout << "作业号\\t\\t提交时间\\t运行时间\\t优先级\\t\\t开始时间\\t终止时间\\t周转时间\\t带权周转时间\\t执行顺序" << endl;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 9; j++)
cout << YXJ[i][j] << "\\t\\t";
cout << endl;
cout << "平均周转时间：" << T << endl;
cout << "带权周转时间：" << W << endl << endl;
break;
default:
break;
if (choice==0)
cout << "已退出！" << endl;
break;
return 0;
以上是关于求一份儿C语言优先级调度算法要求如下的主要内容，如果未能解决你的问题，请参考以下文章