目录
3.13.1 算法的总体思想
3.23.2 轮转调度算法
3. 算法及数据结构........................................................................................................................... 2
算法的总体思想 .................................................................................................................. 2
轮转调度算法模块模块 .............................................................................................................. 2
3.2.1 功能 .......................................................................................................................... 2
3.2.2 数据结构 .................................................................................................................. 3
3.2.3 实现代码(部分) .................................................................................................. 3
3.2.4 实验结果................................................................................................................... 5
3.2.3 算法 .......................................................................................................................... 5
短作业优先算法模块模块 ......................................................................................................... 5
3.3.1 功能........................................................................................................................... 5
3.3.2 数据结构 .................................................................................................................. 6
3.3.3 实现代码(部分) .................................................................................................. 6
3.3.4 算法........................................................................................................................... 8
动态优先级算法模块模块 .......................................................................................................... 8
3.4.1 功能........................................................................................................................... 8
3.4.2 数据结构 .................................................................................................................. 9
3.4.3 实现代码(部分) .................................................................................................. 9
3.4.4 算法......................................................................................................................... 10
4. 程序设计与实现..........................................................................................................................11
4.14.1 程序流程图
程序流程图........................................................................................................................11
4.24.2 程序程序代码代码((全部全部)).................................................................................................................12
3.33.3 短作业优先算法
3.3.44 动态优先级算法
3. 算法及数据结构
3.13.1 算法的总体思想
算法的总体思想
(1)轮转调度调度算法
将所有进程按照先来先服务的规则排成一个队列,把 CPU 分配给就绪队列地对首进
程并规定它的执行时间(称次时间为时间片)当时间片用完但并未执行时,剥夺该进程的执
行将其连接到完成队列地对尾。然后在将下一个进程投入运行,直到所有的运行完毕。
(2)短作业优先调度算法
根据估计运行时间的长短将各个进程排成一个队列(估计运行时间最短的进程放在
对首)每次运行将对首进程投入运行,直道运行结束,将此进程连接到完成队列的队尾。然
后,再将下一个对首投入运行,直到所有的进程都运行完毕。
(3)动态优先级调度算法
为每一个进程设一个优先数,它总是把处理机给就绪队列中具有最高优先级的进
程。初始的进程优先数是随机产生的,随着进程的运行对优先数进行调整,每次运行时都是
从就绪队列中选取优先数最大的进程运行,所以将就绪队列按照优先数的大小从高到低排
序,这样,每次取对首进程即可。将进程按优先数的大小排列在就绪队列中,每次选取就绪
队列中优先权最高的进程首先占用处理机。优先数由随机函数产生进程最初的优先数。优先
数的动态变化:进程每执行一次优先数-1。优先数随着进程的执行进行调整,每次执行时都
从就绪队列中选取优先数最大的进程投入运行。
3.23.2 轮转调度算法
轮转调度算法模块模块
3.2.1 功能
该调度采取了非常公平的处理机分配方式,即让就绪队列上的每一个进程每次仅运行一
个时间片。
3.2.2 数据结构
typedef struct{
//进程块
int id;
//进程名
int reach;
//到达时间
float service;
//服务时间
int prior;
//优先权
int finish;
//完成时间
float turnover;
//周转时间
float cum_turnover;
//带权周转时间
}process;
process p[20];
int sort[20]; //排序数组
int wait[20]; //等待数组
int n; //输入的进程数
int alltime=0;
//运行所需要的时间
char c; //选择的算法
int q;
//时间片
int v;
3.2.3 实现代码(部分)
//时间片轮转法
void timeslice(){
int q; //时间片
int i;
int j;
int front=-1;
int rear=-1;
int t=1;
int v;
printf("\n 请输入时间片:");
scanf("%d",&q);
for(i=0;i<=alltime;i++){
for(j=0;j-1)){ //出队一个元素
if(t==1){
front=(front+1)%20;
v=wait[front];
}
if(t<=q){
p[v].turnover--;
if(p[v].turnover==0){ //进程结束时计算完成时间、周转时间、带权周转时间
//产生时间偏移,有可能存在错误
t=0;
p[v].finish=i+2;
p[v].turnover=p[v].finish-p[v].reach;
p[v].cum_turnover=p[v].turnover/p[v].service;
if(front==rear){ //用来解决进程与进程间的时间空白区
front=-1;
rear=-1;
}
}
if((t==q)&&(p[v].turnover!=0)){
//时间片用完,进入队尾
rear=(rear+1)%20;
wait[rear]=v;
t=0;
}
t++;
}
}
}
}
3.2.4 实验结果
3.2.3 算法
开始
输入进程数
按到达的时间进行排列
将到达的进程放进栈
当 前 进 程 的 服 务 时
间 是 否 大 于 上 一 个
进程的服务时间
是
进程位置对调
否
进程服务时间
是否相同
否
是
进程位置对调
将执行完成的进程信息写入到数组中
输出所有进程的信息
结束
3.33.3 短作业优先算法
短作业优先算法模块模块
3.3.1 功能
在实际情况中,短作业(进程)占有很大的比例,为了能使它们能比长作业优先执行。
3.3.2 数据结构
//进程块
typedef struct{
int id;
int reach;
float service;
int prior;
int finish;
float turnover;
float cum_turnover;
//进程名
//到达时间
//服务时间
//优先权
//完成时间
//周转时间
//带权周转时间
}process;
process p[20];
int sort[20];
int wait[20];
int n;
int alltime=0;
char c;
int v=-1;
//排序数组
//等待数组
//输入的进程数
//选择的算法
//运行所需要的时间
//处理机正在进行处理的进程号
3.3.3 实现代码(部分)
//短作业优先
void sjf(){
int top=-1; //作用于 wait[]
int i;
int j;
int k;
int l;
int temp;
int v=-1;
for(i=0;i<=alltime;i++){
for(j=0;j
if(p[wait[l]].reach
=0)){
//出栈一个进程
v=wait[top];
top--;
}
if(v>-1){
//处理及运行,服务时间自减,这里“turnover“指的是服务时间
p[v].turnover--;
if(p[v].turnover==0){
p[v].finish=i+2;
p[v].turnover=p[v].finish-p[v].reach;
p[v].cum_turnover=p[v].turnover/p[v].service;
v=-1;
}
}
}
}
3.3.4 算法
开始
创建进程
按到达的时间进行排列
输入时间片
将到达的进程放到等待队
执行一个时间片的时间
执 行 进 程 所 用 的 时
间<要求服务时间?
否
是
将执行完成的进程信息写入到数组中
输出所有进程的信息
结束
3.3.44 动态优先级算法
动态优先级算法模块模块
3.4.1 功能
该调度随着进程的推进或等待时间的增加而改变,以便获得更好的调度性能。