当前位置:首页 » 操作系统 » 调度算法

调度算法

发布时间: 2022-01-14 02:27:37

1. 操作系统中的HRRF是什么调度算法

操作系统的常见调度算法有哪些啊?
ABCDE五进程达间别0 1 2 3 4服务间4 3 5 2 4要求按高响应比优先调度算求平均带权周转间

2. 编写代码实现作业的三种调度算法

#include<windows.h>
#include<iostream>
#include<stdio.h>
#include<string>
using namespace std;
const int maxnum=100;
int N; /*进程数*/
double start[maxnum],endtime[maxnum],arrive[maxnum],runtime[maxnum],zhou[maxnum];
double averagezhou; // 平均周转时间
double average_zhou; //平均带权周转时间
char name; //进程名
double dqzhou[maxnum]; //带权周转时间
typedef struct node
{
char name[10]; //进程名
int round; //进程时间轮转时间片
int cputime; //进程占用CPU时间
int needtime; //进程到完成还要的时间
char state; //进程的状态
struct node *next; //链指针
}PCB;
PCB *finish,*ready,*tail,*run; /*队列指针*/

void firstin() /*将就绪队列中的第一个进程投入运行*/
{
run=ready; /*就绪队列头指针赋值给运行头指针*/
run->state='R'; /*进程状态变为运行态*/
ready=ready->next; /*就绪对列头指针后移到下一进程*/
}
void print1(PCB *q) /*进程PCB输出*/
{
printf("进程名 已运行时间 还需要时间 时间片 状态\n");
printf(" %-10s%-15d%-10d%-10d %-c\n",q->name,q->cputime,q->needtime,q->round,q->state);
}
void print() /*输出函数*/
{
PCB *p;
if(run!=NULL) /*如果运行指针不空*/
print1(run); /*输出当前正在运行的PCB*/
p=ready; /*输出就绪队列PCB*/
while(p!=NULL)
{
print1(p);
p=p->next;
}
p=finish; /*输出完成队列的PCB*/
while(p!=NULL)
{
print1(p);
p=p->next;
}
}
void insert(PCB *p2) //轮转法插入函数
{
tail->next=p2; //将新的PCB插入在当前就绪队列的尾
tail=p2;
p2->next=NULL;
}
void create() /*创建进程PCB*/
{
PCB *p;
int i,time;
char na[10];
ready=NULL;
finish=NULL;
run=NULL;
printf("请输入进程名称和所需要CPU的时间:\n");
for(i=1;i<=N;i++)
{
p=(PCB *)malloc(sizeof(PCB));
scanf("%s",na);
scanf("%d",&time);
strcpy(p->name,na);
p->cputime=0;
p->needtime=time;
if(i==1)
p->state='R';
else
p->state='W';
p->round=1; /*时间片*/
if(ready!=NULL)
insert(p);
else
{
p->next=ready;
ready=p;
tail=p;
}
}
printf("------------------------------------------------------------------\n");
print(); /*输出进程PCB信息*/
run=ready; /*将就绪队列的第一个进程投入运行*/
ready=ready->next;
run->state='R';
}
void RR() //时间片轮转调度
{
while(run!=NULL)
{
run->cputime=run->cputime+1;
run->needtime=run->needtime-1;
if(run->needtime==0) /*运行完将其变为完成态,插入完成队列*/
{
run->next=finish;
finish=run;
run->state='F';
run=NULL;
if(ready!=NULL)
firstin(); /*就绪对列不空,将第一个进程投入运行*/
}
else
if(ready!=NULL) /*如就绪队列不空*/
{
run->state='W'; /*将进程插入到就绪队列中等待轮转*/
insert(run);
firstin(); /*将就绪对列的第一个进程投入运行*/
}
printf("------------------------------------------------------------------\n");
print(); /*输出进程信息*/
}
}

void FCFS(double *arrive,double *runtime,double n) //先来先服务调度算法
{
start[0]=arrive[0]; //开始执行时间=到达时间
endtime[0]=start[0]+runtime[0]; //完成时间=开始时间+服务时间
zhou[0]=endtime[0]-arrive[0]; //周转时间=完成时间-到达时间
dqzhou[0]=zhou[0]/runtime[0];
for(int i=0;i<n;i++)
{
if(endtime[i-1]>arrive[i]||endtime[i-1]==arrive[i])
endtime[i]=endtime[i-1]+runtime[i];
else
endtime[i]=arrive[i]+runtime[i];
zhou[i]=endtime[i]-arrive[i];
dqzhou[i]=zhou[i]/runtime[i];
averagezhou+=zhou[i];
average_zhou+=dqzhou[i];
}
averagezhou=averagezhou/n;
average_zhou=average_zhou/n;
cout<<"完成时间为:"<<endl;
for(int j=0;j<n;j++)
cout<<endtime[j]<<" "<<endl;
cout<<"周转时间为:"<<endl;
for(int k=0;k<n;k++)
cout<<zhou[k]<<" "<<endl;
cout<<"带权周转时间为:"<<endl;
for(int m=0;m<n;m++)
cout<<dqzhou[m]<<" "<<endl;
cout<<"平均周转时间为:"<<endl;
cout<<averagezhou<<" "<<endl;
cout<<"平均带权周转时间为:"<<endl;
cout<<average_zhou<<" "<<endl;
}

void SJF(double *arrive,double *runtime,double n) //短作业优先调度算法
{
int end[maxnum]; //用于标记进程是否已经执行,应经执行end[i]=1,否则为0;
for(int k=0;k<n;k++)
end[k]=0;
int temp,now=0,next=1,p=1; //now表示刚执行完的进程号,next表示下一个要执行的进程号
start[0]=arrive[0]; //开始执行时间=到达时间
endtime[0]=start[0]+runtime[0]; //完成时间=开始时间+服务时间
zhou[0]=endtime[0]-arrive[0]; //周转时间=完成时间-到达时间
dqzhou[0]=zhou[0]/runtime[0]; //带权周转时间=周转时间/服务时间
averagezhou=zhou[0];
average_zhou=dqzhou[0];
end[now]=1; //执行完的进程设置为1;
for(int i=1;i<n;i++)
{
int j;
for(j=1;j<n;)
{
if(arrive[j]<endtime[now]||arrive[j]==endtime[now])
j++;
else
break;
}
temp=j;
int min=p;
for(j=1;j<=temp;j++)
{
if(runtime[min]>runtime[j] && end[j]==0)
min=j;
}
next=min;
endtime[next]=endtime[now]+runtime[next];
zhou[next]=endtime[next]-arrive[next];
dqzhou[next]=zhou[next]/runtime[next];
averagezhou+=zhou[next];
average_zhou+=dqzhou[next];
end[next]=1;
now=next;
next=p;
while(end[p]!=0)
p++;
}
averagezhou=averagezhou/n;
average_zhou=average_zhou/n;
cout<<"完成时间为:"<<endl;
for(int j=0;j<n;j++)
cout<<endtime[j]<<" "<<endl;
cout<<"周转时间为:"<<endl;
for(k=0;k<n;k++)
cout<<zhou[k]<<" "<<endl;
cout<<"带权周转时间为:"<<endl;
for(int m=0;m<n;m++)
cout<<dqzhou[m]<<" "<<endl;
cout<<"平均周转时间为:"<<endl;
cout<<averagezhou<<" "<<endl;
cout<<"平均带权周转时间为:"<<endl;
cout<<average_zhou<<" "<<endl;
}

int EDF() //最早截止时间的调度算法
{
int arrive_A,arrive_B; //标记进程A,进程B的到达时间
int zhouqi_A,zhouqi_B,serve_A,serve_B; //进程的周期时间和服务时间
int i,j,a=0,b=0,ka=0,kb=0; //ka,kb为开关,i,j,a,b为进程下标
int num_a=0,num_b=0; //服务累计时间
printf("输入进程A的周期时间,服务时间: ");
scanf("%d%d",&zhouqi_A,&serve_A);
printf("输入进程B的周期时间,服务时间: ");
scanf("%d%d",&zhouqi_B,&serve_B);
for(int T=0;T<=100;T++)
{
if(num_a==serve_A) //进程A完成
{
num_a=serve_A+1;
printf("当T=%d时",T);
printf("进程A%d结束\n",a);
if(num_b<serve_B)
{
printf(" 调用进程B%d\n",b);
kb=1;
}
ka=0;
}
if(num_b==serve_B)
{
num_b=serve_B+1;
printf("当T=%d时",T);
printf("进程B%d结束\n",b);
if(num_a<serve_A)
{
printf(" 调用进程A%d\n",a);
ka=1;
}
kb=0;
}
if(T%zhouqi_A==0 && T%zhouqi_B==0)
{
arrive_A=arrive_B=T;
j=++a;
i=++b;
printf("当T=%d时,进程A%d和进程B%d同时产生,此时,",T,j,i);
if(zhouqi_A<=zhouqi_B)
{
printf("调用进程A%d,阻塞进程B%d\n",j,i);
ka=1;
kb=0;
}
else
{
printf("调用进程B%d,阻塞进程A%d\n",i,j);
ka=0;
kb=1;
}
num_a=num_b=0;
}
if(T%zhouqi_A==0&&T%zhouqi_B!=0)
{
arrive_A=T;
printf("当T=%d时",T);
printf("进程A%d产生 ",++a); //不可能与进程A竞争处理器
num_a=0;
if(num_b<serve_B) //进程B没有完成
if(arrive_B+zhouqi_B>arrive_A+zhouqi_A) //若进程B最早截止时间大于进程A的,则执行进程A
{
printf("进程A%d执行。\n",a);
ka=1;
kb=0;
}
else //若进程B最早截止时间小于等于进程A的
printf("进程B%d继续执行。\n",b);
else //进程B完成
{
printf("进程A%d执行。\n",a);
ka=1;
}
}
if(T%zhouqi_A!=0 && T%zhouqi_B==0)
{
arrive_B=T;
printf("当T=%d时",T);
printf("进程B%d产生,",++b); //不可能与进程B竞争处理器
num_b=0;
if(num_a<serve_A) //进程A没有完成
if(arrive_B+zhouqi_B>=arrive_A+zhouqi_A) //进程A的最早截止时间不小于B
printf("进程A%d继续执行。\n",a);
else
{
printf("进程B%d执行。\n",b);
kb=1;
ka=0;
}

else //进程A完成
{
printf("进程B%d执行。\n",b);
kb=1;
}
}
if(ka)
num_a++;
if(kb)
num_b++;
}
return 1;
}

int main()
{
system("color 0b"); //设置颜色
cout<<"最早截止时间的调度算法如下: "<<endl<<endl;
EDF();
int n;
cout<<endl;
cout<<"请输入进程的数目: ";
cin>>n;
cout<<"请按进程到达时间从小到大依次输入n个进程的到达时间: "<<endl;
for(int i=0;i<n;i++)
cin>>arrive[i];
cout<<"请按上面进程的顺序依次输入n个进程的服务时间: "<<endl;
for(int j=0;j<n;j++)
cin>>runtime[j];
cout<<"先来先服务调度算法如下: "<<endl;
FCFS(arrive,runtime,n);
cout<<endl<<endl;
cout<<"短作业优先调度算法如下: "<<endl;
SJF(arrive,runtime,n);
cout<<endl<<endl;
printf("轮转调度算法如下:\n\n");
printf("输入创建进程的数目:\n");
scanf("%d",&N);
create();
RR();
return 0;
}

3. 进程调度算法是什么

调度算法是指:根据系统的资源分配策略所规定的资源分配算法。
一、先来先服务和短作业(进程)优先调度算法

1. 先来先服务调度算法。先来先服务(FCFS)调度算法是一种最简单的调度算法,该算法既可用于作业调度, 也可用于进程调度。FCFS算法比较有利于长作业(进程),而不利于短作业(进程)。由此可知,本算法适合于CPU繁忙型作业, 而不利于I/O繁忙型的作业(进程)。
2. 短作业(进程)优先调度算法。短作业(进程)优先调度算法(SJ/PF)是指对短作业或短进程优先调度的算法,该算法既可用于作业调度, 也可用于进程调度。但其对长作业不利;不能保证紧迫性作业(进程)被及时处理;作业的长短只是被估算出来的。

二、高优先权优先调度算法

1. 优先权调度算法的类型。为了照顾紧迫性作业,使之进入系统后便获得优先处理,引入了最高优先权优先(FPF)调度算法。 此算法常被用在批处理系统中,作为作业调度算法,也作为多种操作系统中的进程调度,还可以用于实时系统中。当其用于作业调度, 将后备队列中若干个优先权最高的作业装入内存。当其用于进程调度时,把处理机分配给就绪队列中优先权最高的进程,此时, 又可以进一步把该算法分成以下两种:
1)非抢占式优先权算法
2)抢占式优先权调度算法(高性能计算机操作系统)
2. 优先权类型 。对于最高优先权优先调度算法,其核心在于:它是使用静态优先权还是动态优先权, 以及如何确定进程的优先权。
3. 高响应比优先调度算法
为了弥补短作业优先算法的不足,我们引入动态优先权,使作业的优先等级随着等待时间的增加而以速率a提高。 该优先权变化规律可描述为:优先权=(等待时间+要求服务时间)/要求服务时间;即 =(响应时间)/要求服务时间

三、基于时间片的轮转调度算法

1. 时间片轮转法。时间片轮转法一般用于进程调度,每次调度,把CPU分配队首进程,并令其执行一个时间片。 当执行的时间片用完时,由一个记时器发出一个时钟中断请求,该进程被停止,并被送往就绪队列末尾;依次循环。 2. 多级反馈队列调度算法 多级反馈队列调度算法多级反馈队列调度算法,不必事先知道各种进程所需要执行的时间,它是目前被公认的一种较好的进程调度算法。 其实施过程如下:
1) 设置多个就绪队列,并为各个队列赋予不同的优先级。在优先权越高的队列中, 为每个进程所规定的执行时间片就越小。
2) 当一个新进程进入内存后,首先放入第一队列的末尾,按FCFS原则排队等候调度。 如果他能在一个时间片中完成,便可撤离;如果未完成,就转入第二队列的末尾,在同样等待调度…… 如此下去,当一个长作业(进程)从第一队列依次将到第n队列(最后队列)后,便按第n队列时间片轮转运行。
3) 仅当第一队列空闲时,调度程序才调度第二队列中的进程运行;仅当第1到第(i-1)队列空时, 才会调度第i队列中的进程运行,并执行相应的时间片轮转。
4) 如果处理机正在处理第i队列中某进程,又有新进程进入优先权较高的队列, 则此新队列抢占正在运行的处理机,并把正在运行的进程放在第i队列的队尾。

4. 什么rm调度算法

一个任务的响应时间(response time)是指一个任务请求, 这个任务实际完成的时间跨度. 在静态调度中, 任务的临界时刻(critical instant)这个概念被首先提出来. 它被定义为一个特定的时刻, 如果在这个时刻有这个任务的请求, 那么这个任务就会需要最大的响应时间. 由此得出 定理1: 一个任务的临界时间就是比这个任务优先级高的所有任务同时发出请求的时刻. 定理1的价值在于它找到了一个证明一个调度算法能否调度任一任务集充分必要条件, 那就是所有任务同时请求执行的时的情况下每个任务仍能满足各自的期限, 那么这个任务集就可以被这个调度算法调度. 有了这个推论, 我们就可以证明RM调度的最优性了. 定理2: 如果一个任务集能够被静态调度, 那么RMS算法就能够调度这个任务集. 从这个意义上说, RMS是最优的静态调度算法. 这个定理的证明方法就是有名的交换法. 证明思路如下: 假设一个任务集S采用其他静态优先级算法可以调度,那么总有这样两个优先级相邻的任务i和j, 有Ti>Tj,而Pi≤Pj.把Ti和Tj的优先级Pi和Pj互换,明显可以看出这时S仍然可以调度, 因为在所有任务同时请求的情况下, 交换这两个任务不会影响其它任务的完成时间, 同时这两个任务都可以在各自期限内完成. 按照这样的方法,其他任何静态优先级调度最终都可以转换成RM调度. RMS已被证明是静态最优调度算法, 开销小, 灵活性好, 是实时调度的基础性理论。即使系统瞬时过载, 也完全可预测哪些任务丢失时限。缺点是处理机利用率较低, 最坏的情况下,当n→∞时, 不超过ln2 (≈ 70%)。另外, RMS是充分但非必要条件。而在一般情况下,对于随机的任务集大约只有88%. 70%或者88%的处理器利用率对于许多实时应用来说是一个严重的限制,动态调度算法如最早截止期最先(earliest deadline first,EDF)或者最少空闲时间最先(least laxity first,LLF)已经被证明是最优的,并且能够实现100% 的处理器利用率. 具有资源同步约束的RMS调度 当实时任务间共享资源时, 可能出现低优先级任务不可预测地阻塞高优先级任务执行的情况, 叫优先级倒置。这时RMS 算法不能保证任务集的调度, 必须使用有关协议控制优先级的倒置时间。常用的协议有优先级顶级协议和堆资源协议, 使用这些协议可使优先级的倒置时间最多为一个资源临界段的执行时间, 并且不会发生死锁。 基于RMS 的非周期任务的调度 实时系统中的非周期任务可采用延迟服务器算法或随机服务器算法进行调度。它们的最大特点是可在周期任务的实时调度环境下处理随机请求。两者的基本思想是将非周期任务转化成周期任务, 再利用RMS算法进行调度。前者用一个或几个专用的周期任务执行所有非周期任务, 这种周期任务叫非周期任务服务器。根据周期大小,服务器有固定优先级, 服务器的执行时间被称为预算, 它在每个服务器周期Ts 的起点补充。只要服务器有充足的预算, 就可在其周期内为非周期任务服务。该算法实现简单, 但可调度性分析较难, 有时会出现抖动, 可能发生一个非周期任务在相邻两个服务器周期中连续执行2倍预算的现象, 与RMS理论不符, 需要适当修改RMS算法。随机服务器算法与延迟服务器算法相似, 但预算不是在每个周期起点补充, 而是在预算消耗Ts时间之后再补充。该算法与RMS分析算法一致, 但实现复杂。 EDF最早截止时间优先算法(EDF)也称为截止时间驱动调度算法(DDS),是一种动态调度算法。EDF指在调度时,任务的优先级更具任务的截止时间动态分配。截止时间越短,优先级越高。EDF有如下定理: 定理2:如果一个任务集按EDF算法调度,当且仅当U<=1。 EDF的特点(1) 任务模型: 与RMS 调度相同。 (2) 优先级分配方法: 动态分配, 距要求时限所剩时间越短优先级越高。 理论上,EDF和LLF算法都是单处理器下的最优调度算法。但是由于EDF和LLF在每个调度时刻都要计算任务的deadline或者空闲时间,并根据计算结果改变任务优先级,因此开销大、不易实现,其应用受到一定限制。多处理器实时调度

5. 什么是调度算法

调度算法

通常将作业或进程归入各种就绪或阻塞队列。有的算法适用于作业调度,有的算法适用于进程调度,有的两者都适应。

1.先来先服务(FCFS, First Come First Serve)

先来先服务(FCFS, First Come First Serve)是最简单的调度算法,按先后顺序进行调度。

1. FCFS算法

按照作业提交或进程变为就绪状态的先后次序,分派CPU;

当前作业或进程占用CPU,直到执行完或阻塞,才出让CPU(非抢占方式)。

在作业或进程唤醒后(如I/O完成),并不立即恢复执行,通常等到当前作业或进程出让CPU。最简单的算法。

2. FCFS的特点

比较有利于长作业,而不利于短作业。

有利于CPU繁忙的作业,而不利于I/O繁忙的作业。

2. 轮转法(Round Robin)

轮转法(Round Robin)是让每个进程在就绪队列中的等待时间与享受服务的时间成正比例。

1. 轮转法

Ø 将系统中所有的就绪进程按照FCFS原则,排成一个队列。

Ø 每次调度时将CPU分派给队首进程,让其执行一个时间片。时间片的长度从几个ms到几百ms。

Ø 在一个时间片结束时,发生时钟中断。

Ø 调度程序据此暂停当前进程的执行,将其送到就绪队列的末尾,并通过上下文切换执行当前的队首进程。

Ø 进程可以未使用完一个时间片,就出让CPU(如阻塞)。

Ø

2. 时间片长度的确定

Ø 时间片长度变化的影响

² 过长->退化为FCFS算法,进程在一个时间片内都执行完,响应时间长。

² 过短->用户的一次请求需要多个时间片才能处理完,上下文切换次数增加,响应时间长。

Ø 对响应时间的要求:T(响应时间)=N(进程数目)*q(时间片)

Ø 就绪进程的数目:数目越多,时间片越小

Ø 系统的处理能力:应当使用户输入通常在一个时间片内能处理完,否则使响应时间,平均周转时间和平均带权周转时间延长。

3. 多级反馈队列算法(Round Robin with Multiple Feedback)

多级反馈队列算法时间片轮转算法和优先级算法的综合和发展。

优点:

² 为提高系统吞吐量和缩短平均周转时间而照顾短进程。

² 为获得较好的I/O设备利用率和缩短响应时间而照顾I/O型进程。

² 不必估计进程的执行时间,动态调节。

1. 多级反馈队列算法

² 设置多个就绪队列,分别赋予不同的优先级,如逐级降低,队列1的优先级最高。每个队列执行时间片的长度也不同,规定优先级越低则时间片越长,如逐级加倍。

² 新进程进入内存后,先投入队列1的末尾,按FCFS算法调度;若按队列1一个时间片未能执行完,则降低投入到队列2的末尾,同样按FCFS算法调度;如此下去,降低到最后的队列,则按“时间片轮转”算法调度直到完成。

² 仅当较高优先级的队列为空,才调度较低优先级的队列中的进程执行。如果进程执行时有新进程进入较高优先级的队列,则抢先执行新进程,并把被抢先的进程投入原队列的末尾。

²

2. 几点说明

² I/O型进程:让其进入最高优先级队列,以及时响应I/O交互。通常执行一个小时间片,要求可处理完一次I/O请求的数据,然后转入到阻塞队列。

² 计算型进程:每次都执行完时间片,进入更低级队列。最终采用最大时间片来执行,减少调度次数。

² I/O次数不多,而主要是CPU处理的进程。在I/O完成后,放回优先I/O请求时离开的队列,以免每次都回到最高优先级队列后再逐次下降。

² 为适应一个进程在不同时间段的运行特点,I/O完成时,提高优先级;时间片用完时,降低优先级。

6. 调度算法的调度算法

在操作系统中调度是指一种资源分配,因而调度算法是指:根据系统的资源分配策略所规定的资源分配算法。对于不同的的系统和系统目标,通常采用不同的调度算法,例如,在批处理系统中,为了照顾为数众多的段作业,应采用短作业优先的调度算法;又如在分时系统中,为了保证系统具有合理的响应时间,应当采用轮转法进行调度。目前存在的多种调度算法中,有的算法适用于作业调度,有的算法适用于进程调度;但也有些调度算法既可以用于作业调度,也可以用于进程调度。
通常将作业或进程归入各种就绪或阻塞队列。
调度算法要求:高资源利用率、高吞吐量、用户满意等原则。
进程调度所采用的算法是与整个系统的设计目标相一致的:
1.批处理系统:增加系统吞吐量和提高系统资源的利用率;
2.分时系统:保证每个分时用户能容忍的响应时间。
3.实时系统:保证对随机发生的外部事件做出实时响应。

7. 几种进程调度算法分析

前两天做操作系统作业的时候学习了一下几种进程调度算法,在思考和讨论后,有了一些自己的想法,现在就写出来,跟大家讨论下。 ,或者说只有有限的CPU资源,当系统中有多个进程处于就绪状态,要竞争CPU资源时,操作系统就要负责完成如何分配资源的任务。在操作系统中,由调度程序来完成这一选择分配的工作,调度程序所使用的算法即是调度算法。调度算法需要考虑的指标主要有尽量保证CPU资源分配的公平性;按照一定策略强制执行算法调度;平衡整个计算机系统,尽量保持各个部分都处于忙碌状态。而根据系统各自不同的特点和要求,调度算法又有一些侧重点和目标不同,因此,算法按照系统差异主要分为三大类: 批处理系统中的调度算法, 代表调度算法有:先来先服务、最短作业优先、最短剩余时间优先。 交互式系统中的调度算法, 代表调度算法有:轮转调度、优先级调度、多级队列、最短进程优先、保证调度、彩票调度、公平分享调度。 实时系统中的调度算法 ,代表调度算法有:速率单调调度、最早最终时限优先调度。 下面就上述提到的调度算法中挑出几个进行重点分析:保证调度保证调度是指利用算法向用户做出明确的性能保证,然后尽力按照此保证实现CPU的资源分配。利用这种算法,就是定一个进程占用CPU的时间的标准,然后按照这个标准去比较实际占用CPU的时间,调度进程每次使离此标准最远的进程得到资源,不断满足离所保证的标准最远的进程,从而平衡资源分配满足这个标准的要求。 保证调度算法的优点是:能很好的保证进程公平的CPU份额,当系统的特点是:进程的优先级没有太大悬殊,所制定的保证标准差异不大,各个进程对CPU的要求较为接近时,比如说系统要求n个进程中的每个进程都只占用1/n的CPU资源,利用保证调度可以很容易的实现稳定的CPU分配要求。但缺点是,这种情况太过理想,当系统的各个进程对CPU要求的紧急程度不同,所制定的保证较为复杂的时候,这个算法实现起来比较困难。 彩票调度彩票调度这种算法的大意是指向进程提供各种系统资源如CPU资源的彩票,当系统需要做出调度决策时,随机抽出一张彩票,由此彩票的拥有者获得资源。在彩票调度系统中,如果有一个新的进程出现并得到一些彩票,那么在下一次的抽奖中,该进程会有同它持有彩票数量成正比例的机会赢得奖励。进程持有的彩票数量越多,则被抽中的可能性就越大。调度程序可以通过控制进程的彩票持有数量来进行调度。 彩票调度有很多优点:首先,它很灵活,系统增加分给某个进程的彩票数量,就会大大增加它占用资源的可能性,可以说,彩票调度的反应是迅速的,而快速响应需求正是交互式系统的一个重要要求。其次,彩票调度算法中,进程可以交换彩票,这个特点可以更好的保证系统的平衡性,使其各个部分都尽可能的处于忙碌状态。而且利用彩票调度还可以解决许多别的算法很难解决的问题,例如可以根据特定的需要大致成比例的划分CPU的使用。 速率单调调度 速率单调调度算法是一种可适用于可抢占的周期性进程的经典静态实时调度算法。当实时系统中的进程满足:每个周期性进程必须在其周期内完成,且进程之间没有相互依赖的关系,每个进程在一次突发中需要相同的CPU时间量,非周期的进程都没有最终时限四个条件时,并且为了建模方便,我们假设进程抢占即刻发生没有系统开销,可以考虑利用速率单调算法。 速率单调调度算法是将进程的速率(按照进程周期所算出的每秒响应的次数)赋为优先级,则保证了优先级与进程速率成线性关系,这即是我们所说的速率单调。调度程序每次运行优先级最高的,只要优先级较高的程序需要运行,则立即抢占优先级低的进程,而优先级较低的进程必须等所有优先级高于它的进程结束后才能运行。 速率单调调度算法可以保证系统中最关键的任务总是得到调度,但是缺点是其作为一种静态算法,灵活性不够好,当进程数变多,系统调度变得复杂时,可能不能较好的保证进程在周期内运行。 最早最终时限优先调度 最早最终时限优先调度算法是一个动态算法,不要求进程是周期性的,只要一个进程需要CPU时间,它就宣布它的到来时间和最终时限。调度程序维持一个可运行的进程列表,按最终时限排序,每次调度一个最终时限最早的进程得到CPU 。当新进程就绪时,系统检查其最终时限是否在当前运行的进程结束之前,如果是,则抢占当前进程。 由于是动态算法,最早最终优先调度的优点就是灵活,当进程数不超过负载时,资源分配更优,但也同样由于它的动态属性,进程的优先级都是在不断变化中的,所以也没有哪个进程是一定可以保证满足调度的,当进程数超过负载时,资源分配合理度会急速下降,所以不太稳定。

8. 虚拟存储器采用的页面调度算法是“先进先出”(FIFO)算法吗

虚拟存储器采用的页面调度算法是“先进先出”(FIFO)算法吗。常见的替换算法有4种。

①随机算法:用软件或硬件随机数产生器确定替换的页面。

②先进先出:先调入主存的页面先替换。

③近期最少使用算法(LRU,Least Recently Used):替换最长时间不用的页面。

④最优算法:替换最长时间以后才使用的页面。这是理想化的算法,只能作为衡量其他各种算法优劣的标准。

虚拟存储器的效率是系统性能评价的重要内容,它与主存容量、页面大小、命中率,程序局部性和替换算法等因素有关。

(8)调度算法扩展阅读

虚拟存储器地址变换基本上有3种形虚拟存储器工作过程式:全联想变换、直接变换和组联想变换。任何逻辑空间页面能够变换到物理空间任何页面位置的方式称为全联想变换。每个逻辑空间页面只能变换到物理空间一个特定页面的方式称为直接变换。

组联想变换是指各组之间是直接变换,而组内各页间则是全联想变换。替换规则用来确定替换主存中哪一部分,以便腾空部分主存,存放来自辅存要调入的那部分内容。

在段式虚拟存储系统中,虚拟地址由段号和段内地址组成,虚拟地址到实存地址的变换通过段表来实现。每个程序设置一个段表,段表的每一个表项对应一个段,每个表项至少包括三个字段:有效位(指明该段是否已经调入主存)、段起址(该段在实存中的首地址)和段长(记录该段的实际长度)。

9. 关于《操作系统》中的磁盘调度算法

(1)先来先服务调度算法
由于该算法就是按照磁道请求序列的先后次序依次访问磁道的,因此磁道的访问序列(服务顺序)就是:
110、180、32、115、15、120、60、70。
当前磁头在50号磁道。故磁头移动道数为:
(110-50)+(180-110)+(180-32)+(115-32)+(115-15)+(120-15)+(120-60)+(70-60)=60+70+148+83+100+105+60+10=636
(2)单向扫描调度算法
该算法是沿磁头移动方向访问距离当前磁道最近的磁道,当到达一个顶端时立刻返回到另一个顶端继续扫描。本题磁头移动方向是磁道增加的方向,当前磁头在50号磁道。因此磁道的访问序列(服务顺序)就是:60、70、110、115、120、180、15、32。而磁头移动道数与前面(1)问差不多,也是两两相减,然后求和。在此略

热点内容
安卓上哪里下大型游戏 发布:2024-12-23 15:10:58 浏览:185
明日之后目前适用于什么配置 发布:2024-12-23 14:56:09 浏览:51
php全角半角 发布:2024-12-23 14:55:17 浏览:826
手机上传助手 发布:2024-12-23 14:55:14 浏览:729
什么样的主机配置吃鸡开全效 发布:2024-12-23 14:55:13 浏览:827
安卓我的世界114版本有什么 发布:2024-12-23 14:42:17 浏览:707
vbox源码 发布:2024-12-23 14:41:32 浏览:274
诗经是怎么存储 发布:2024-12-23 14:41:29 浏览:656
屏蔽视频广告脚本 发布:2024-12-23 14:41:24 浏览:417
php解析pdf 发布:2024-12-23 14:40:01 浏览:816