CPU调度算法
五章处理机管理CPUScheduling
调度期Dispatch Latency
事件
响应事件
中断 处理
调度周期
调度
时实进 程执行
对实时系统的要求
提供必要的调度信息
进程的就绪时间 进程开始执行截止时间和完成执行截止时间 进程处理所需时间 进程的资源要求 进程优先级
调度方式 具有快速响应外部中断的能力
实时调度算法
Real-Time Scheduling
2.多处理机操作系统的分类
本节所介绍的多处理机操作系统是指那些用来并行执 行用户的几个程序,以提高系统的吞吐率;或 并行操作 以提高系统可靠性的多处理操作系统。这种系统由共享公 共内存和外设的n(n>1)个 CPU组成。
从概念上说,在多处理机系统中的各进程的行为与在 单机系统下的行为相同。因此,对多处理机操作系统的要 求与对多道程序的批处理系统没有太多的区别。但是,多 处理环境下,进程可在各处理机间进行透明迁移,从而, 由进程上下文切换等带来的系统开销将使得多处理机操作 系统的复杂度大大增加。另外,由于多处理机系统并行地 执行用户的几个程序(进程),这又带来了多处理机条件 下的并发执行问题。
Performance
q large FIFO q small q must be large with respect to context switch,
otherwise overhead is too high.
Example of RR with Time Slice= 1 时间片为1时的例子
If there are n processes in the ready queue and the time slice is q, then each process gets 1/n of the CPU time in chunks of at most q time units at once. No process waits more than (n-1)q time units.
操作系统中的CPU调度
操作系统中的CPU调度一、CPU调度的基本概念CPU调度是操作系统的一个非常重要的功能,它控制着CPU 在多任务环境下的运作。
在多任务环境下,CPU必须要对不同的进程进行处理,CPU调度就是指根据一定的算法,在所有可执行的进程中选择一个进程,让它占用CPU,运行一段时间,并在执行完毕后释放CPU,然后选择下一个可执行的进程进行处理,这样就能够合理地利用CPU资源,提高系统的响应速度和吞吐量。
二、CPU调度的基本算法CPU调度的主要任务是在可执行的进程中选择一个进程让其运行,并在一定的时间之后切换到另一个进程进行处理。
但是,在实际中需要考虑的问题是如何选择进程,并且进程切换所带来的开销不能太大。
因此,CPU调度的算法就成了关键。
CPU调度算法主要有以下几种:1. 先来先服务算法(FCFS)FCFS是最早的调度算法,它简单易懂,就是按照进程到达的顺序来排序,先到达的进程先执行,完成后才能运行后面到达的进程。
但是,这种算法存在“饥饿”现象,即如果某个进程运行时间过长,其他进程就无法得到及时的处理。
2. 最短作业优先算法(SJF)SJF算法是根据进程的运行时间来排序的。
处理器会选择那些需要时间最短的进程进行处理。
这种算法速度快,但是会出现“饥饿”现象,即某些进程的运行时间太长,导致其他进程无法得到及时的处理。
3. 时间片轮转算法(RR)RR算法是在时间片为单位对进程进行轮流处理。
每个进程分配一个时间片,当时间片用完时,处理器会停止这个进程的运行,并且把它放到等待队列的末尾,然后从队列的头部选择下一个进程。
这种算法能够避免“饥饿”的现象,但是会带来一定的上下文切换开销。
4. 优先级算法(Priority)Priority算法是根据进程的优先级进行判断的。
进程的优先级越高,就越容易被处理器调度。
但是,这种算法存在的问题就是某些优先级低的进程可能会一直得不到执行。
5. 多级反馈队列算法(MFQ)MFQ算法是一种复杂的算法,它将进程划分为多个队列,分配不同的时间片用于不同的队列。
cpu时间管理思维方法
CPU时间管理思维方法1. 引言在计算机领域,CPU(Central Processing Unit)被认为是计算机系统中最重要的组件之一。
它负责执行所有的指令和处理数据,因此对于优化CPU的使用非常重要。
时间管理是一种思维方法,旨在最大程度地利用CPU的时间,以提高计算机系统的整体性能和效率。
本文将介绍几种CPU时间管理的思维方法,并讨论它们在不同情况下的应用。
2. 抢占式调度方法抢占式调度是一种常见的CPU时间管理方法,主要用于多任务操作系统中。
在抢占式调度中,操作系统可以随时剥夺当前运行的进程的CPU时间,并将其分配给其他就绪的进程。
这种方法可以确保高优先级的任务优先得到执行,并提高系统的响应能力。
抢占式调度方法适用于需要实时响应的系统,如实时操作系统和多媒体应用程序。
通过灵活地分配CPU时间,可以避免某个进程长时间占用CPU,从而保证系统的平稳运行。
3. 时间片轮转调度算法时间片轮转调度算法是一种常见的抢占式调度方法,它将CPU时间分为固定长度的时间片,每个进程在一个时间片内运行一段时间,然后被剥夺CPU时间,给其他进程运行的机会。
被剥夺的进程将排在就绪队列的末尾,等待下一次调度。
时间片轮转调度算法的优点是公平性,所有进程在长时间内都有机会获得CPU时间。
然而,它也存在一些缺点,如进程切换的开销较大,会影响系统的响应时间。
4. 优先级调度算法优先级调度算法是一种非抢占式调度方法,根据进程的优先级来分配CPU时间。
高优先级的进程将优先获得CPU时间,而低优先级的进程则被推迟执行。
这种方法适用于那些对实时性要求不是很高或没有硬实时要求的系统。
优先级调度算法的好处是可以通过调整进程的优先级来灵活地分配CPU时间,以适应不同的情况和需求。
然而,如果不合理地设置优先级,可能会导致低优先级进程被长时间忽视,从而降低系统的公平性和性能。
5. 后台任务调度方法在某些情况下,系统中可能存在一些后台任务,它们不需要实时响应,但对系统的整体性能和效率有一定的影响。
CPU调度算法准则及原理
P1 P2 P3 P4 P5 P1 P5 P1 P5 P1 P1
0 2 3 5 6 8 10 12 14 15 18 19 平均等待时间: {[(0+(8-2))+(12-10)+(15-14)]+2+3+5+[6+(14-12)+(108)]}/5=5.8
进程
CPU区间时间
P1
10
P2
1
P3
2
P4
实时调度
1. 实时计算分为硬实时(hard real-time)和软实时( soft real-time)
2. 实现软实时功能要求 1) 系统必须有优先权调度,且实时进程必须有最高的优 先权 2) 分派延迟必须小
3. 为了让分派延迟保持很小,需要允许系统可抢占,实现 方法有 1) 在长时间系统调用内插入抢占点(preemption point)-内核安全位置 2) 使整个内核可抢占-同步机制保护内核数据结构
进程来执行,进程选择是由CPU调度程序来执行的,又称 为短期调度程序(short-term scheduler) • 就绪队列可实现为FIFO队列、优先队列、树或无序链表 等形式
2
3、可抢占式调度
• CPU调度决策发生的环境
1) 当一个进程从运行状态切换到等待状态 2) 当一个进程从运行状态切换到就绪状态 3) 当一个进程从等待状态切换到就绪状态 4) 当一个进程终止时 • 非抢占(nonpreemptive)调度(1、4情况) • 可抢占(preemptive)调度(2、3情况) • 可抢占调度的代价 1) 共享数据的不一致性问题 2) 影响操作系统内核的设计
9
补充:最高响应比优先算法
• 响应比R=周转时间/执行时间
处理机调度算法的比较
处理机调度算法的比较计算机科学学院计算机科学与技术2009摘要:处理机调度基本概念、调度算法优劣的评价准则、多种处理机调度算法的介绍引言操作系统是处理计算机硬件的一层软件和作为计算机用户与计算机硬件的中间的协调者。
操作系统的CPU调度器负责给各个任务分发CPU带宽资源。
调度算法负责管理当前执行任务等额顺序和性能3 内容:3.1 处理机调度的基本概念高/中/低级调度1. 高级调度(作业调度)决定把外存上处于后备队列中的哪些作业调入内存,并为它们创建进程、分配必要的资源,准备执行。
2. 低级调度(进程调度)决定就绪队列中的哪个进程应获得处理机,然后再由分派程序执行把处理机分配给该进程的具体操作。
非抢占方式和抢占方式3. 中级调度决定把又具备运行条件的挂起进程重新调入内存,挂到就绪队列上,准备执行。
3.2 调度算法优劣的评价准则衡量和比较调度算法性能优劣主要有一下几个因素:(1)CPU利用率。
CPU是计算机系统中最重要的资源,所以应尽可能使CPU保持忙,使这一资源利用率最高。
(2)吞吐量。
CPU运行时表示系统正处于工作状态,工作量的大小是以每单位时间所完成的作业数目来描述的,这就叫吞吐量。
(3)周转时间。
指从作业提交到作业完成所经过的时间,包括作业等待,在就绪队列中排队,在处理机上运行以及进行输入/输出操作所花时间的总和。
(4)等待时间。
处理机调度算法实际上并不影响作业执行或输入/输出操作的时间,只影响作业在就绪队列中等待所花的时间。
因此,衡量一个调度算法优劣常常简单的考察等待时间。
(5)响应时间。
指从作业提交到系统作出相应所经过的时间。
在交互式系统中,作业的周转时间并不一定是最好的衡量准则,因此,常常使用另一种度量准则,即相应时间。
从用户观点看,响应时间应该快一点好,但这常常要牺牲系统资源利用率为代价。
(6)公平性——确保每个用户每个进程获得合理的 CPU 份额或其他资源份额,不会出现饿死情况。
当然,这些目标本身就存在着矛盾之处,操作系统在设计时必须根据其类型的不同进行权衡,以达到较好的效果。
CPU调度——精选推荐
CPU调度CPU调度引⼊了线程,对于⽀持它们的操作系统,是内核级的线程被操作系统调度,⽽不是进程。
不过,术语线程调度或进程调度常常被交替使⽤。
在讨论普通调度概念时使⽤进程调度,特别指定为线程概念时使⽤线程调度。
基本概念CPU-I/O区间周期CPU的成功调度依赖于进程的如下属性:进程执⾏由CPU执⾏和I/O等待周期组成。
进程在这两个状态之间切换。
进程执⾏从CPU区间(CPU burst)开始,在这之后是I/O区间(I/O burst),接着是另⼀个CPU区间,然后是另⼀个I/O区间,如此进⾏下去。
CPU调度程序每当CPU空闲时,操作就必须从就绪队列中选择⼀个进程来执⾏。
进程选择由短期调度程序(short-term scheduler)或CPU调度程序执⾏。
调度程序从内核中选择⼀个能够执⾏的进程,并为之分配CPU。
就绪队列不必是先进先出(FIFO)队列。
就绪队列可实现为FIFO队列,优先队列,树或简单的⽆序链表。
不过从概念上来说,就绪队列内的所有进程都要排队以等待在CPU上运⾏。
队列中的记录通常为进程控制块(PCB)。
抢占调度CPU调度决策可在如下4种环境下发⽣:当⼀个进程从运⾏状态切换到等待状态(例如,I/O请求,或调⽤wait等待⼀个⼦进程的终⽌)。
当⼀个进程从运⾏状态切换到就绪状态(例如,当出现中断时)当⼀个进程从等待状态切换到就绪状态(例如,I/O完成)当⼀个进程终⽌对于第1和第4两种情况,没有选择⽽只有调度。
⼀个新进程(如果就绪队列中已有⼀个进程存在)必须被选择执⾏。
不过,对于第2和第3两种情况,可以进⾏选择。
当调度只能发⽣在第1和第4两种情况下时,称调度⽅案是⾮抢占的(nonpreemptive)的或协作的(cooperative);否则,称调度⽅案是抢占的(preemptive)。
采⽤⾮抢占调度,⼀旦CPU分配给⼀个进程,那么该进程会⼀直使⽤CPU知道进程终⽌或切换到等待状态。
中断能随时发⽣,⽽且不能总是被内核所忽视,所以受中断影响的代码段必须加以保护以避免同时访问。
操作系统第13讲:第4章 处理机调度调度算法.ppt
2019/10/31
18
4.6 实时系统调度方算法简介
四、时限调度算法
导语:基本思想是:按用户的时限要求顺序设置优先级,优先
●实时系统所处理的外部任务可分为周期性的与非周期性的两大类。非周期性 任务,存在有一个完成或开始进行处理时限;而周期性任务要求在周期T内 完成或开始进行处理。
2019/10/31
13
4.6 实时系统调度算法简介
一、实时系统的特点
1.有限等待和响应时间(决定性) 2.可靠性高 3.用户可以控制 4.系统纠错能力强,实时系统要求很高的可靠性。
导语:
●实时系统广泛用在移动通信、网络计算、航空航天等领域。os是实时系统中 最重要的部分之一,它负责在用户要求的时限内进行事件处理和控制。
●实时系统与其他系统的最大区别:处理和控制的正确性不仅取决于计算的逻 辑结果,而且取决于计算和处理结果产生的时间。因此,实时系统的调度, 即把给定的任务,按所要求的时限调配到相应的设备上处理完成。根据实 时系统对处理外部事件的时限要求,分为硬、软实时任务。 ◆硬实时任务要求系统必须完全满足任务的时限要求。 ◆软实时任务允许时限要求有一定的延迟,时限要求只是一个相对条件。
注意P90: 周转T、完成T、提交T、带权周转T等概念在公式中的含义。 ●分析结论:P3 执行的时间非常短,但等待时间过长,显然是不合理的。
2019/10/31
3
4.4 调度算法
二、短作业或短进程调度算法(SJF)
1. 适应范围:作业或进程 2. 原则:选取最短作业或进程进行执行 3. 优点:当短作业或短进程较多时,系统效率较高 4. 缺陷:对长作业不利,设有考虑优先级
优先级调度算法原理和短进程优先调度算法原理
一、优先级调度算法原理优先级调度算法是一种用于操作系统中的进程调度的算法。
该算法根据每个进程的优先级来决定它在CPU上的执行顺序。
优先级通常是一个整数值,较小的优先级值表示较高的优先级。
当一个进程需要被调度时,系统会选择具有最高优先级的进程来执行。
1.1 优先级调度算法的工作原理在优先级调度算法中,每个进程被分配一个优先级值。
当系统需要选择一个进程来执行时,它会选择具有最高优先级的进程。
如果有多个进程具有相同的最高优先级,那么系统可能会根据其他因素来进行决策,比如先到先服务(FIFO)的原则。
1.2 优先级调度算法的特点优先级调度算法的特点是能够根据进程的优先级来进行调度,从而有效地提高系统的响应速度。
然而,如果进程的优先级分配不合理,可能会导致低优先级的进程长时间得不到执行的机会,造成饥饿现象。
1.3 优先级调度算法的应用场景优先级调度算法通常适用于对实时性要求较高的系统,比如多媒体应用或者交互式应用。
在这些系统中,需要优先处理一些关键的任务,以确保系统的响应速度和稳定性。
二、短进程优先调度算法原理短进程优先调度算法是一种按照进程需要的CPU时间长度进行调度的算法。
该算法先选择需要运行时间最短的进程来执行,从而能够有效地提高系统的吞吐量和响应速度。
2.1 短进程优先调度算法的工作原理在短进程优先调度算法中,系统会根据每个进程需要运行的时间长度来进行调度。
当系统需要选择一个进程来执行时,它会选择需要运行时间最短的进程。
这样可以确保每个进程都能够及时得到执行,并且能够有效地提高系统的吞吐量和响应速度。
2.2 短进程优先调度算法的特点短进程优先调度算法的特点是能够有效地提高系统的吞吐量和响应速度。
由于选择运行时间最短的进程来执行,可以确保每个进程都能够及时得到执行,从而减少了平均等待时间和平均周转时间。
2.3 短进程优先调度算法的应用场景短进程优先调度算法通常适用于需要平衡系统的吞吐量和响应速度的场景,比如多用户系统或者交互式系统。
[整理]操作系统的三大调度机制及算法
[整理]操作系统的三⼤调度机制及算法⽬录操作系统的三⼤调度机制,分别是「进程调度/页⾯置换/磁盘调度算法」。
进程调度算法进程调度算法也称 CPU 调度算法,毕竟进程是由 CPU 调度的。
当 CPU 空闲时,操作系统就选择内存中的某个「就绪状态」的进程,并给其分配 CPU。
什么时候会发⽣ CPU 调度呢?通常有以下情况:1. 当进程从运⾏状态转到等待状态;2. 当进程从运⾏状态转到就绪状态;3. 当进程从等待状态转到就绪状态;4. 当进程从运⾏状态转到终⽌状态;其中发⽣在 1 和 4 两种情况下的调度称为「⾮抢占式调度」,2 和 3 两种情况下发⽣的调度称为「抢占式调度」。
⾮抢占式的意思就是,当进程正在运⾏时,它就会⼀直运⾏,直到该进程完成或发⽣某个事件⽽被阻塞时,才会把 CPU 让给其他进程。
⽽抢占式调度,顾名思义就是进程正在运⾏的时,可以被打断,使其把 CPU 让给其他进程。
那抢占的原则⼀般有三种,分别是:时间⽚原则、优先权原则、短作业优先原则。
你可能会好奇为什么第 3 种情况也会发⽣ CPU 调度呢?假设有⼀个进程是处于等待状态的,但是它的优先级⽐较⾼,如果该进程等待的事件发⽣了,它就会转到就绪状态,⼀旦它转到就绪状态,如果我们的调度算法是以优先级来进⾏调度的,那么它就会⽴马抢占正在运⾏的进程,所以这个时候就会发⽣ CPU 调度。
那第 2 种状态通常是时间⽚到的情况,因为时间⽚到了就会发⽣中断,于是就会抢占正在运⾏的进程,从⽽占⽤ CPU。
调度算法影响的是等待时间(进程在就绪队列中等待调度的时间总和),⽽不能影响进程真在使⽤ CPU 的时间和 I/O 时间。
接下来,说说常见的调度算法:1. 先来先服务调度算法2. 最短作业优先调度算法3. ⾼响应⽐优先调度算法4. 时间⽚轮转调度算法5. 最⾼优先级调度算法6. 多级反馈队列调度算法先来先服务调度算法最简单的⼀个调度算法,就是⾮抢占式的先来先服务(First Come First Severd, FCFS)算法了。
CPU调度算法
一、设计目的通过CPU调度相关算法的实现,了解CPU调度的相关知识,通过实现CPU调度算法,理解CPU的管理,以及不同的CPU调度算法实现过程。
体会算法的重要性。
二、设计要求1、编写算法,实现FCFS、非抢占SJF、可抢占优先权调度2、针对模拟进程,利用CPU调度算法进行调度3、进行算法评估,计算平均周转时间和平均等待时间4、调度所需的进程参数由输入产生(手工输入或者随机数产生)5、输出调度结果6、输出算法评价指标三、设计说明1、采用数组、指针2、FCFS先来先服务调度算法是一种最简单的调度算法,当作业调度中采用该算法时,每次调度都是从后备作业队列中选择一个最先进入该队列的作业3、非抢占SJF短作业优先调度算法,是指对短作业有限调度算法。
是从后备队列中选择一个估计运行时间最短的作业将他们调入内存。
4、可抢占优先权调度在这种方式下,系统把处理机分配给优先权最高的进程,使之执行。
但在其执行期间,只要出现另一个其优先权更高的进程,进程调度程序就立即停止当前进程(原优先权最高的进程)的执行,重新将处理及分配给新到的优先权最高的进程。
四、程序流程图。
1、可抢占优先权调度算法2、FCFS3、非抢占SJF五、程序部分1、FCFS#include<>#include<>typedef struct PCB{char name[10];char state;int arrivetime;int starttime;int finishtime;int servicetime;float turnaroundtime;float weightedturnaroundtime;struct PCB *next;}pcb;int time;pcb *head=NULL,*p,*q;void run_fcfs(pcb *p1){time=p1->arrivetime>timep1->arrivetime:time;p1->starttime=time;printf("\n现在时间是%d,开始运行作业%s\n",time,p1->name);time+=p1->servicetime;p1->state="T";p1->finishtime=time;p1->turnaroundtime=p1->finishtime-p1->arrivetime;p1->weightedturnaroundtime=p1->turnaroundtime/p1->servicetime;printf(" 到达时间开始时间服务时间完成时间周转时间带权周转时间\n ");printf("%6d%10d%10d%8d%%\n",p1->arrivetime,p1->starttime,p1->servicetime,p1->finishtime,p1->turnaroundtime, p1->weightedturnaroundtime);}void fcfs(){int i,j;p=head;for(i=0;i<n;i++){if(p->state=='F'){q=p;run_fcfs(q);}p=p->next;}}void getInfo(){int num;printf("\n作业个数:");scanf("%d",&n);for(num=0;num<n;num++){p=(pcb*)malloc(sizeof(pcb));printf("依次输入:进程名到达时间服务时间\n");scanf("%s%d%d",&p->name,&p->arrivetime,&p->servicetime);if(head==NULL){head=p;q=p;time=p->arrivetime;}if(p->arrivetime<time)time=p->arrivetime;q->next=p;p->starttime=0;p->finishtime=0;p->turnaroundtime=0;p->weightedturnaroundtime=0;p->next=NULL;p->state='F';q=p;}}void main(){ system("graftabl 936");printf("先来先服务算法模拟");getInfo();p=head;fcfs();}2、非抢占SJF#include<>#include<>#define MAX 100struct jcb{char name[10];float arrivetime;float starttime;float finishtime;float servicetime;float zztime;float avezztime;};struct jcb a[MAX];void input(jcb *p,int N){ int i;printf("请分别输入\n\t进程名到达时间服务时间\n\n");for(i=0;i<=N-1;i++){printf("请输入第%d个进程信息:",i+1);scanf("%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].servicetime);printf("\n");}}void Print(jcb *p, float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float avezztime,int N){int k;printf("调度顺序:");printf("%s",p[0].name);for(k=1;k<N;k++){printf("-->%s",p[k].name);}printf("\n\n");printf("\t\t\t进程信息:\n");printf("\nname\tarrive\tservice\tstart\tfinish\tzz\tavezz\n");for(k=0;k<=N-1;k++){printf("%s\t%\t%\t%\t%\t%\t%\t\n",p[k].name,p[k].arrivetime,p[k].servicetime,p [k].starttime,p[k].finishtime,p[k].zztime,p[k].avezztime);}}void sort(jcb *p,int N){int i,j;for(i=0;i<=N-1;i++)for(j=0;j<=i;j++)if(p[i].arrivetime<p[j].arrivetime){jcb temp;temp=p[i];p[i]=p[j];p[j]=temp;}}void deal(jcb *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &avezztime,int N){int k;for(k=0;k<=N-1;k++){if(k==0){p[k].starttime=p[k].arrivetime;p[k].finishtime=p[k].arrivetime+p[k].servicetime;}else{p[k].starttime=p[k-1].finishtime;p[k].finishtime=p[k-1].finishtime+p[k].servicetime;}}for(k=0;k<=N-1;k++){p[k].zztime=p[k].finishtime-p[k].arrivetime;p[k].avezztime=p[k].zztime/p[k].servicetime;}}void jcbf(jcb *p,int N){ float arrivetime=0, servicetime=0, starttime=0, finishtime=0, zztime=0, avezztime=0;int m,n,next,k,i=0;float min;sort(p,N);for(m=0;m<N-1;m++){if(m==0)p[m].finishtime=p[m].arrivetime+p[m].servicetime;elsep[m].finishtime=p[m-1].finishtime+p[m].servicetime;for( n=m+1;n<=N-1;n++){if(p[n].arrivetime<=p[m].finishtime)i++;}min=p[m+1].servicetime;next=m+1;for(k=0;k<m+i;k++){if(p[k+1].servicetime<min){min=p[k+1].servicetime;next=k+1;}}{jcb temp;temp=p[m+1];p[m+1]=p[next];p[next]=temp;}deal(p,arrivetime,servicetime,starttime,finishtime,zztime,avezztime,N);Print(p,arrivetime,servicetime,starttime,finishtime,zztime,avezztime,N);}}int main(){int N,*b; char ch;while(1){system("CLS");system("graftabl 936");printf("\t\t\t------短作业优先调度算法------\n");printf("输入进程个数:");scanf("%d",&N);if(N>MAX){printf("\t!!输入的作业数目太大,请输入不大于%d的整数\n",MAX); printf("按Q或者q退出程序,按其他任意键继续测试...");ch=getch();if(ch=='Q'||ch=='q'){break;}else continue;}input(a,N);jcb *b=a;jcbf(b,N);printf("按Q或者q退出程序,按其他任意键继续测试...");ch=getch();if(ch=='Q'||ch=='q'){break;}}return 0;getch();}3、可抢占优先权调度算法#include<>#include<>#include<>#include<>#include<>#include<>typedef char string[10];struct task{string name;int arrTime;int serTime;int waiTime;int begTime;int finTime;int turTime;int wTuTime;int priority;int finish;}JCB[10];int num;void input(){int i;system("cls");printf("\n请输入作业数量:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n请输入作业NO.%d:\n",i);printf("作业名称:");scanf("%s",JCB[i].name);printf("到达时间:");scanf("%d",&JCB[i].arrTime);printf("服务时间:");scanf("%d",&JCB[i].serTime);JCB[i].priority=0;JCB[i].finish=0;}}int HRN(int pre){int current=1,i,j;for(i=0;i<num;i++){JCB[i].waiTime=JCB[pre].finTime-JCB[i].arrTime;JCB[i].priority=(JCB[i].waiTime+JCB[i].serTime)/JCB[i].serTime;}for(i=0;i<num;i++){if(!JCB[i].finish){current=i;break;}}for(j=i;j<num;j++){if(!JCB[j].finish){if(JCB[current].arrTime<=JCB[pre].finTime){if(JCB[j].arrTime<=JCB[pre].finTime&&JCB[j].priority>JCB[current].priority) current=j;}else{if(JCB[j].arrTime<JCB[current].arrTime)current=j;if(JCB[j].arrTime==JCB[current].arrTime)if(JCB[j].priority>JCB[current].priority)current=j;}}}return current;}void runing(int i,int times,int pre,int staTime,int endTime){if(times=0){JCB[i].begTime=JCB[i].arrTime;JCB[i].finTime=JCB[i].begTime+JCB[i].serTime;JCB[i].turTime=JCB[i].serTime;JCB[i].wTuTime=;staTime=JCB[i].begTime;}else{if(JCB[i].arrTime>JCB[pre].finTime)JCB[i].begTime=JCB[i].arrTime;elseJCB[i].begTime=JCB[pre].finTime;JCB[i].finTime=JCB[i].begTime+JCB[i].serTime;JCB[i].turTime=JCB[i].finTime-JCB[i].arrTime;JCB[i].wTuTime=JCB[i].turTime/JCB[i].serTime;}if(times==num-1)endTime=JCB[i].finTime;JCB[i].finish=1;}void print(int i,int times){if(times==0){printf("名称到达时间服务时间开始时间完成时间周转时间带权周转时间\n");}printf("%3s%9d%9d%9d%9d%9d%9d\n",JCB[i].name,JCB[i].arrTime,JCB[i].serTime,JCB[ i].begTime,JCB[i].finTime,JCB[i].turTime,JCB[i].wTuTime);}void check(){int i;int staTime,endTime,sumTurTime=,sumWTuTime=,aveturTime,aveWTuTime;int current=0,times=0,pre=0;JCB[pre].finTime=0;for(i=0;i<num;i++){JCB[i].finish=0;}staTime,endTime,sumTurTime=,sumWTuTime=,aveturTime,aveWTuTime;current=0;times=0;pre=0;printf("-------------------------------------------\n");for(i=0;i<num;i++){JCB[i].finish=0;}staTime,endTime,sumTurTime=,sumWTuTime=,aveturTime,aveWTuTime;current=0;times=0;pre=0;printf("-------HRRN-------------------------------------\n");for(times=0;times<num;times++){current=HRN(pre);runing(current,times,pre,staTime,endTime);print(current,times);pre=current;}for(i=0;i<num;i++){sumTurTime+=JCB[i].turTime;sumWTuTime+=JCB[i].wTuTime;}aveturTime=sumTurTime/num;aveWTuTime=sumWTuTime/num;printf("<计与平均值>%9d%9d%9d%9d\n",NULL,sumTurTime,aveturTime,aveWTuTime);printf("-------------------------------------------------------\n");}void main(){char again;system("graftabl 936");do{system("cls");printf("请输入4组数据:");input();check();printf("Continue...(Y/N):");do{again=getch();}while(again!='Y'&&again!='y'&&again!='N'&&again!='n');}while(again=='Y'||again=='y');getch();}六、运行结果七、实验总结1、FCFS算法,即先来先服务,就是每次从就绪队列中选择一个最先进入队列的进程,把CPU分配给它,令它运行。
cpu调度算法
The scheduler’s moves are dictated by a scheduling policy.
Wakeup or ReadyToRun Scheduler ready pool SWITCH() GetNextToRun()
Scheduler Goals
• response time or latency
• FCFS is just like the checkout line at the QuickiMart.
Maintain a queue ordered by time of arrival. GetNextToRun selects from the front of the queue.
Priority
Some goals can be met by incorporating a notion of priority into a “base” scheduling discipline.
Each job in the ready pool has an associated priority value;the scheduler favors jobs with higher priority values.
How long does it take to do what I asked? (R)
• throughput
How many operations complete per unit of time? (X) Utilization: what percentage of time does the CPU (and each device) spend doing useful work? (U)
CPU调度
层。当它分配到CPU ,可执行 8 ms。如果它 8 ms后没有执行完 毕,则迁移至Q1层。否则,它离开就绪队列 ,该干嘛干嘛。
在Q1层,当它分配到CPU,可执行
16 ms 。如果它 16 ms后没有执行完毕,则迁移至 Q2层。否则,它离开就绪队列,该干嘛干嘛 。
34
设计多层反馈队列
SJF (抢占式)
P1 0 2 P2 4
P3
P2 5 7
P4 11
P1 16
平均等待时间 = (9 + 1 + 0 +2)/4 = 3
14
两种SJF策略比较
非抢占式(Non-Preemptive) – 一旦CPU分配给了某个
进程,就不能“抢过来”,除非该进程主动放弃CPU (CPU burst cycle结束,或者进程转去做I/O操作)
16
进入就绪队列的进程怎么“预估”CPU时间?
不可能准确地预测,为什么?(e.g. 等待输入数据) 只能根据过去的CPU burst cycles拟合
例如,指数平均Exponential average思想
1. t n actual lenght of n th CPU burst 2. n 1 predicted value for the next CPU burst 3. , 0 1 4. Define :
n 1 t n 1 n.
17
图,“指数平均”求进程的下一个CPU Burst Cycle
18
假如设计一个新算法: HRN (Highest response Ratio Next)
HRN = (W + T) / T
cpu调度算法
CPU调度算法关键字: cpu调度算法操作系统两种进程调度算法:1)优先数调度;2)循环轮转调度①本程序用两种算法对五个进程进行调度,每个进程可有三个状态,并假设初始状态为就绪状态。
②为了便于处理,程序中的某进程运行时间以时间片为单位计算。
各进程的优先数或轮转时间数以及进程需运行的时间片数的初始值均由用户给定。
③在优先数算法中,优先数可以先取值为98,进程每执行一次,优先数减3,CPU时间片数加1,进程还需要的时间片数减1。
在轮转算法中,采用固定时间片(即:每执行一次进程,该进程的执行时间片数为已执行了2个单位),这时,CPU时间片数加2,进程还需要的时间片数减2,并排列到就绪队列的尾上。
④对于遇到优先数一致的情况,采用FIFO策略解决。
#include<stdio.h>#include <dos.h>#include<stdlib.h>#include<conio.h>#include<iostream.h>#define P_NUM 5#define P_TIME 50enum state{ready,execute,block,finish};struct pcb{char name[4];int priority;int cputime;int needtime;int count;int round;state process;pcb * next;};pcb * get_process();pcb * get_process(){pcb *q;pcb *t;pcb *p;int i=0;cout<<"input name and time"<<endl;while (i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb)); cin>>q->name;cin>>q->needtime;q->cputime=0;q->priority=P_TIME-q->needtime; q->process=ready;q->next=NULL;if (i==0){p=q;t=q;}else{t->next=q;t=q;}i++;} //whilereturn p;}void display(pcb *p){cout<<"name"<<" "<<"cputime"<<" "<<"needtime"<<" "<<"priority"< <" "<<"state"<<endl;while(p){cout<<p->name;cout<<" ";cout<<p->cputime;cout<<" ";cout<<p->needtime;cout<<" ";cout<<p->priority;cout<<" ";switch(p->process){case ready:cout<<"ready"<<endl;break;case execute:cout<<"execute"<<endl;break;case block:cout<<"block"<<endl;break;case finish:cout<<"finish"<<endl;break;}p=p->next;}}int process_finish(pcb *q){int bl=1;while(bl&&q){bl=bl&&q->needtime==0;q=q->next;}return bl;}void cpuexe(pcb *q){pcb *t=q;int tp=0;while(q){if (q->process!=finish){q->process=ready;if(q->needtime==0){q->process=finish;}}if(tp<q->priority&&q->process!=finish){tp=q->priority;t=q;}q=q->next;}if(t->needtime!=0){t->priority-=3;t->needtime--;t->process=execute;t->cputime++;}}void priority_cal(){pcb * p;clrscr();p=get_process();int cpu=0;clrscr();while(!process_finish(p)){cpu++;cout<<"cputime:"<<cpu<<endl;cpuexe(p);display(p);sleep(2);clrscr();}printf("All processes have finished,press any key to exit"); getch();}void display_menu(){cout<<"CHOOSE THE ALGORITHM:"<<endl; cout<<"1 PRIORITY"<<endl;cout<<"2 ROUNDROBIN"<<endl;cout<<"3 EXIT"<<endl;}pcb * get_process_round(){pcb *q;pcb *t;pcb *p;int i=0;cout<<"input name and time"<<endl;while (i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));cin>>q->name;cin>>q->needtime;q->cputime=0;q->round=0;q->count=0;q->process=ready;q->next=NULL;if (i==0){p=q;t=q;}else{t->next=q;t=q;}i++;} //whilereturn p;}void cpu_round(pcb *q){q->cputime+=2;q->needtime-=2;if(q->needtime<0) {q->needtime=0;}q->count++;q->round++;q->process=execute;}pcb * get_next(pcb * k,pcb * head){pcb * t;t=k;do{t=t->next;}while (t && t->process==finish);if(t==NULL){t=head;while (t->next!=k && t->process==finish){ t=t->next;}}return t;}void set_state(pcb *p){while(p){if (p->needtime==0){p->process=finish;}if (p->process==execute){p->process=ready;}p=p->next;}}void display_round(pcb *p){cout<<"NAME"<<" "<<"CPUTIME"<<" "<<"NEEDTIME"<<" "<<"COU NT"<<" "<<"ROUND"<<" "<<"STATE"<<endl;while(p){cout<<p->name;cout<<" ";cout<<p->cputime;cout<<" ";cout<<p->needtime;cout<<" ";cout<<p->count;cout<<" ";cout<<p->round;cout<<" ";switch(p->process){case ready:cout<<"ready"<<endl;break;case execute:cout<<"execute"<<endl;break;case finish:cout<<"finish"<<endl;break;}p=p->next;}}void round_cal(){pcb * p;pcb * r;clrscr();p=get_process_round();int cpu=0;clrscr();r=p;while(!process_finish(p)){cpu+=2;cpu_round(r);r=get_next(r,p);cout<<"cpu "<<cpu<<endl;display_round(p);set_state(p);sleep(5);clrscr();}}void main(){display_menu();int k;scanf("%d",&k);switch(k){case 1:priority_cal();break; case 2:round_cal();break; case 3:break;display_menu();scanf("%d",&k);}}。
第六章 CPU调度
14
先来先服务
护航效果: 护航效果:
– 短进程跟在长进程之后,或者大量 约束 短进程跟在长进程之后,或者大量I/O约束 进程等待一个CPU约束进程释放 约束进程释放CPU 进程等待一个 约束进程释放
小结
– 易于理解,易于实现(通过先进先出队列实 易于理解,易于实现( 现) – 等待和响应时间变化较大 – 护航效果 – 非抢占式,不利于分时系统 非抢占式,
τn+1 = α tn+(1 - α) α tn-1 + … +(1 - α )j α tn-j + … +(1 - α )n+1 τ0
21
6.3.3优先权调度 优先权调度
每个进程都有一个优先权(一个整数) 每个进程都有一个优先权(一个整数) 与其关联 具有最高优先权的进程会被分配到 具有最高优先权的进程会被分配到CPU, , 具有相同优先权的进程按FCFS顺序调度 具有相同优先权的进程按 顺序调度
第六章 CPU调度 调度
内容
基本概念 调度准则 调度算法 多处理器调度 实时调度 算法评估 进程调度模型
2
6.1 基本概念
多道程序设计的基本目标 使CPU利用率最 多道程序设计的基本目标: 利用率最 大化
– 多个进程可同时处于进程中 – 当一个进程必须等待时,操作系统拿走 当一个进程必须等待时,操作系统拿走CPU控 控 制权,并将CPU交给其它的进程。 交给其它的进程。 制权,并将 交给其它的进程
– 抢占式
如果新进程具有较高的优先级,则抢占优先权调度 如果新进程具有较高的优先级, 算法抢占CPU 算法抢占
– 非抢占式
如果新进程具有较高的优先级,仅仅将新进程放到 如果新进程具有较高的优先级, 队列头
CPU调度算法
CPU调度算法 1、先到先服务调度算法(FCFS) 根据就绪队列的到达时间来服务,此时就绪队列是⼀个FIFO队列,先到先服务,后到的线程不能抢占前⾯正在服务的线程。
这种算法的优点是实现简单,缺点也很明显,就是CPU进程区间变化很⼤时,平均等待时间会变化很⼤。
2、最短作业优先调度(SJF) 顾名思义,就是CPU进程区间最短的先执⾏,如果两个进程区间具有同样的长度,那么按照FCFS来调度。
SJF可以是抢占的,也可以是不抢占的。
它的平均等待时间优于FCFS。
3、优先级调度 其实上⾯的SJF算法就是⼀种特殊的优先级调度,只不过这⾥的优先级定义更加⼴泛⼀些,SJF算法的优先级是按照CPU进程区间长短来定义的,这⾥的优先级可以是其他的⼀些定义。
优先级调度可以是抢占的,也可以是⾮抢占的。
优先级调度的⼀个主要问题是⽆穷阻塞(也称为饥饿),如果⼀个线程的优先级很低,可能需要等待很长的时间才能到这个线程执⾏,甚⾄永远不执⾏,⼀种解决⽅法是⽼化(随着时间的增长,增加线程的优先级) 4、轮转法调度(RR) 轮转法调度专门是为分时系统设计的。
它类似于FCFS,但是增加了抢占为了切换线程。
定义⼀个较⼩的时间单元,称为时间⽚,通常为10-100ms。
为了实现RR算法,将就绪队列保存为FIFO队列,新进程增加到就绪队列队尾,CPU调度程序从就绪队列选择第⼀个进程,设置定时器在⼀个时间⽚之后再中断,再分派这个进程。
如果该进程的CPU区间⼩于时间⽚,进程本⾝就会释放CPU,调度程序继续处理下⼀个进程,如果当前进程的CPU区间⽐时间⽚长,定时器会产⽣CPU中断,实⾏上下⽂切换,然后将此进程放到就绪队列队尾,继续调度就绪队列第⼀个进程。
5、多级队列调度: 这⾥对进程进⾏分组,在组内使⽤FCFS和SJF算法,在组间实⾏优先级调度或者轮转法调度。
但是不允许进程在组间切换。
6、多级反馈队列调度 允许进程在组间切换,主要思想是根据不同区间的特点区分进程,如果CPU进程占⽤过多CPU时间,那么它会被转移到更低优先级队列。
处理器调度算法c语言
处理器调度算法c语言一、概述处理器调度算法是操作系统中一个非常重要的问题。
在多任务操作系统中,有多个进程同时运行,而处理器只有一个,因此需要对进程进行调度,使得每个进程都能够得到适当的执行时间。
二、常见的处理器调度算法1. 先来先服务(FCFS)FCFS算法是最简单的调度算法之一。
它按照进程到达时间的先后顺序进行调度,即先到达的进程先执行。
这种算法容易实现,但可能会导致长作业等待时间过长。
2. 最短作业优先(SJF)SJF算法是根据每个进程所需的CPU时间来进行排序,并按照顺序进行调度。
这种算法可以减少平均等待时间和平均周转时间,并且可以最大限度地利用CPU资源。
3. 优先级调度优先级调度是根据每个进程的优先级来进行排序,并按照顺序进行调度。
这种算法可以确保高优先级进程得到更多的CPU时间,但可能会出现低优先级进程饥饿问题。
4. 时间片轮转(RR)RR算法将CPU分配给每个任务一定量的时间片,在该时间片内运行任务。
如果任务在该时间片内未完成,则将其放回队列尾部,并分配给下一个任务时间片。
这种算法可以确保公平性,并且可以避免长作业等待时间过长。
三、C语言中的处理器调度算法实现1. FCFS算法实现#include <stdio.h>int main(){int n, i, j;float avg_waiting_time = 0, avg_turnaround_time = 0;printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], waiting_time[n], turnaround_time[n];printf("Enter the burst time for each process:\n");for(i=0; i<n; i++)scanf("%d", &burst_time[i]);waiting_time[0] = 0;turnaround_time[0] = burst_time[0];for(i=1; i<n; i++){waiting_time[i] = waiting_time[i-1] + burst_time[i-1];turnaround_time[i] = waiting_time[i] + burst_time[i];avg_waiting_time += waiting_time[i];avg_turnaround_time += turnaround_time[i];}avg_waiting_time /= n;avg_turnaround_time /= n;printf("\nProcess\tBurst Time\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\n", i+1, burst_time[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround_ time);return 0;}2. SJF算法实现#include <stdio.h>int main(){int n, i, j, temp;float avg_waiting_time = 0, avg_turnaround_time = 0; printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], waiting_time[n], turnaround_time[n]; printf("Enter the burst time for each process:\n");for(i=0; i<n; i++)scanf("%d", &burst_time[i]);for(i=0; i<n-1; i++)for(j=i+1; j<n; j++)if(burst_time[i] > burst_time[j]){temp = burst_time[i];burst_time[i] = burst_time[j]; burst_time[j] = temp;}waiting_time[0] = 0;turnaround_time[0] = burst_time[0];for(i=1; i<n; i++){waiting_time[i] = waiting_time[i-1] + burst_time[i-1];turnaround_time[i] = waiting_time[i] + burst_time[i];avg_waiting_time += waiting_time[i];avg_turnaround_time += turnaround_time[i];}avg_waiting_time /= n;avg_turnaround_time /= n;printf("\nProcess\tBurst Time\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\n", i+1, burst_time[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround_ time);return 0;}3. 优先级调度算法实现#include <stdio.h>int main(){int n, i, j, temp;float avg_waiting_time = 0, avg_turnaround_time = 0;printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], waiting_time[n], turnaround_time[n], priority[n];printf("Enter the burst time and priority for each process:\n"); for(i=0; i<n; i++)scanf("%d %d", &burst_time[i], &priority[i]);for(i=0; i<n-1; i++)for(j=i+1; j<n; j++)if(priority[i] > priority[j]){temp = priority[i];priority[i] = priority[j];priority[j] = temp;temp = burst_time[i];burst_time[i] = burst_time[j]; burst_time[j] = temp;}waiting_time[0] = 0;turnaround_time[0] = burst_time[0];for(i=1; i<n; i++){waiting_time[i] = waiting_time[i-1] + burst_time[i-1];turnaround_time[i] = waiting_time[i] + burst_time[i];avg_waiting_ time += waiting_ time[i];avg_turnaround_ time += turnaround_ time[i];}avg_waiting_ time /= n;avg_turnaround_ time /= n;printf("\nProcess\tBurst Time\tPriority\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\t\t%d\n", i+1, burst_ time[i], priority[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround _ time);return 0;}4. RR算法实现#include <stdio.h>int main(){int n, i, j, time_quantum;float avg_waiting_time = 0, avg_turnaround_time = 0;printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], remaining_time[n], waiting_time[n], turnaround_time[n];printf("Enter the burst time for each process:\n");for(i=0; i<n; i++)scanf("%d", &burst_time[i]);printf("Enter the time quantum: ");scanf("%d", &time_quantum);for(i=0; i<n; i++)remaining_time[i] = burst_time[i];int t=0;while(1){int done = 1;for(i=0; i<n; i++){if(remaining_time[i] > 0){done = 0;if(remaining_ time[i] > time_ quantum){t += time_ quantum;remaining_ time[i] -= time_ quantum;}else{t += remaining _ time[i];waiting_time[i] = t - burst_time[i];remaining_ time[i] = 0;turnaround_ time[i] = waiting_time[i] + burst_time[i];avg_waiting_ time += waiting_ time[i];avg_turnaround _ time += turnaround_ time[i];}}}if(done == 1)break;}avg_waiting_ time /= n;avg_turnaround_ time /= n;printf("\nProcess\tBurst Time\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\n", i+1, burst_time[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround _ time);return 0;}四、总结以上是常见的处理器调度算法的C语言实现方式。
CPU调度
- 16 -
9.3 调度算法
CPU调度算法
(1)先到先服务调度 FCFS
(2)最短作业优先调度 SJF (3)优先级调度 (4)转轮法调度 RR (5)多级队列调度 (6)多级反馈队列调度
- 17 -
(1)FIFO或First Come, First Served (FCFS)
-1-
9.1 基本概念
(1)什么是CPU调度?
每当CPU空闲时,操作系统必须按照一定的策略从
就绪队列当中选择一个进程来执行。 调度的对象:进程或线程。其方式与原则是一样的。 故经常以进程来说明:进程调度 <==> CPU调度
(2)CPU调度遵循什么原则?
总原则:资源高效、公平合理 具体一般包括: 提高CPU利用率 提高系统运算的吞吐量 缩短进程的周转时间 缩短进程的等待时间 提高用户的响应满意度 ……
SRJF
SJF
平均等待时间(SRJF): (3+32+0+8+0)/5 = 8.6 平均等待时间(SJF): (0+20+5+8+19)/5 = 10.4
到达时间 CPU区间 (ms) (ms) 0 0 5 5 30 10 29 3 7 12
抢占显然具有优点
P5
SJF(SRJF): 如何知道下一CPU区间大小
时间片太小
吞吐量变小,周转时间变长 如时间片20ms,上下文切换5ms,20%的切换代价
折中: 时间片10-100ms,切换时间0.1-1ms(1%)
- 29 -
RR调度例子:周转时间随着时间片大小而变化
处理机调度算法
处理机调度算法处理机调度算法(CPU Scheduling Algorithm)是操作系统中一个非常重要的概念,它指的是在多个进程需要占用系统处理器的情况下,如何高效地分配时间片,使得每个进程都能得到公平的处理机时间,系统能够充分利用处理器的资源。
算法分类常见的处理机调度算法主要有以下几种:1. 先来先服务(FCFS)调度算法先来先服务是最简单的处理机调度算法。
它的基本思想是,一个进程需要处理时,处理器按照进程提交的顺序进行调度。
即,先提交的进程先执行,等前一个进程执行完后,下一个进程才会被处理。
这种算法的优点是简单易行,缺点是可能导致一些进程等待时间较长。
2. 短作业优先(SJF)调度算法短作业优先是一种非抢占式的算法,它的基本思想是根据每个进程需要处理的总时间长短来排序,先处理需要处理时间较短的作业,这种方法可以最小化平均等待时间。
但是,由于它需要知道每个进程的总执行时间,因此难以实现。
3. 时间片轮转(RR)调度算法时间片轮转是一种抢占式的算法,它的基本思想是将处理机分为时间片,每个进程都可以运行一个时间片,时间片到期后,如果还未结束,则该进程被挂起,另一个就绪进程插入,并重新分配一个时间片。
这种算法能够避免某些进程长时间占用资源,每个进程都能在一定时间内得到处理机的时间。
4. 优先级调度(Priority Scheduling)算法优先级调度是一种非抢占式的算法,它的基本思想是为每个进程设置不同的优先级,进程具有最高优先级的先被处理,如果存在两个相等的进程优先级,那么会使用先来先服务的方式进行处理。
缺点是可能导致低优先级的进程等待时间太长。
5. 多级反馈队列(MFQ)调度算法多级反馈队列是一种复杂的算法,它的基本思想是将所有进程按照其优先级分为多个队列,优先级相同的进程被分成同一个队列,不同队列之间根据时间片大小相差不同。
例如,第一队列的时间片为10ms,第二队列的时间片为20ms,第三队列的时间片为40ms,以此类推。
操作系统的计算资源调度
操作系统的计算资源调度在操作系统中,计算资源调度是至关重要的一项任务。
计算资源包括CPU、内存、磁盘、网络等硬件资源,调度的目的是合理地分配这些资源,以提高系统的整体性能和效率。
CPU资源调度是操作系统中最为常见和重要的调度任务之一。
在计算资源有限的情况下,多个进程需要共享CPU资源,而操作系统需要根据一定的调度算法来合理地分配CPU时间片,以确保各个进程能够得到公平的执行机会。
常见的CPU 调度算法包括先来先服务(FCFS)、短作业优先(SJF)、优先级调度、轮转调度等。
内存资源调度也是操作系统中的重要任务之一。
在多道程序设计环境下,多个进程需要同时驻留在内存中并共享内存资源。
因此,操作系统需要动态地管理内存空间,包括内存的分配、回收、置换等操作。
常见的内存调度算法包括首次适应算法、最佳适应算法、最坏适应算法等。
此外,磁盘资源调度也是操作系统中不可忽视的任务。
磁盘I/O操作是系统中频繁发生的操作,而磁盘资源有限,且磁盘的读写速度相对较慢。
因此,操作系统需要设计合适的磁盘调度算法,来减少磁盘的寻道时间和旋转时间,提高磁盘I/O 的效率。
常见的磁盘调度算法包括先来先服务(FCFS)、最短寻道时间优先(SSTF)、扫描算法、循环扫描算法等。
此外,网络资源调度也是操作系统中的一项重要任务。
在现代计算机系统中,多个进程之间通常需要通过网络进行通信,而网络带宽是有限的。
因此,操作系统需要合理地调度网络资源,以保证各个进程之间的通信能够顺利进行。
常见的网络调度算法包括公平队列调度(FQ)、最短剩余路径(SRT)、随机早期检测(RED)等。
总的来说,计算资源调度是操作系统中非常重要的一个任务,它直接影响到系统的性能和效率。
合理地调度计算资源可以提高系统的整体性能,确保系统能够高效地运行。
操作系统需要根据不同的硬件资源特点和应用场景,选择合适的调度策略和算法,以实现最佳的资源分配效果。
通过不断优化计算资源的调度策略,可以提高操作系统的稳定性、安全性和性能,从而满足用户对系统性能的不断提升的需求。
操作系统中的CPU调度技术
操作系统中的CPU调度技术一、CPU调度技术的定义与目的CPU调度技术是操作系统中的一个关键功能,其主要目的是合理地分配和管理计算机系统中的CPU资源,确保各个进程能够高效、公平地获得CPU时间,以提高系统的整体性能和吞吐量。
二、CPU调度技术的分类1.先来先服务调度算法(FCFS)先来先服务调度算法是一种最简单的CPU调度算法。
根据进程到达CPU的顺序进行调度,先到达的进程先执行。
该算法适用于进程长度较短、CPU繁忙的场景,但缺点是可能导致“饥饿”现象,即短进程被长进程阻塞。
2.短作业优先调度算法(SJF)短作业优先调度算法是根据进程的运行时间进行调度的算法。
该算法优先执行运行时间较短的进程,以减少平均等待时间。
SJF算法可分为两种:非抢占式和抢占式。
3.优先级调度算法优先级调度算法是根据进程的优先级进行调度的算法。
每个进程被赋予一个优先级,CPU总是调度优先级最高的进程。
优先级可以根据进程的需求、重要性等因素进行设置。
该算法可能导致低优先级进程长时间得不到执行,即“饥饿”现象。
4.时间片调度算法(RR)时间片调度算法是一种基于抢占式的CPU调度算法。
将CPU时间分成若干个时间片,每个进程在一个时间片内执行。
如果进程未完成,将被放入就绪队列末尾,等待下一次调度。
该算法可以避免进程长时间占用CPU,提高系统吞吐量。
5.多级反馈队列调度算法多级反馈队列调度算法是一种复杂的CPU调度算法,结合了多种调度算法的优点。
将进程分为多个队列,每个队列有不同的优先级。
进程在不同队列间根据执行情况动态调整优先级。
该算法既考虑了进程的运行时间,又避免了“饥饿”现象。
三、CPU调度技术的影响因素1.进程的运行时间进程的运行时间直接影响CPU调度算法的性能。
短作业优先调度算法适用于运行时间较短的进程,而时间片调度算法可以确保长进程和短进程都能得到执行。
2.进程的优先级优先级调度算法根据进程的优先级进行调度,优先级高的进程优先执行。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
一、设计目的通过CPU调度相关算法的实现,了解CPU调度的相关知识,通过实现CPU调度算法,理解CPU的管理,以及不同的CPU调度算法实现过程。
体会算法的重要性。
二、设计要求1、编写算法,实现FCFS、非抢占SJF、可抢占优先权调度2、针对模拟进程,利用CPU调度算法进行调度3、进行算法评估,计算平均周转时间和平均等待时间4、调度所需的进程参数由输入产生(手工输入或者随机数产生)5、输出调度结果6、输出算法评价指标三、设计说明1、采用数组、指针2、FCFS先来先服务调度算法是一种最简单的调度算法,当作业调度中采用该算法时,每次调度都是从后备作业队列中选择一个最先进入该队列的作业3、非抢占SJF短作业优先调度算法,是指对短作业有限调度算法。
是从后备队列中选择一个估计运行时间最短的作业将他们调入内存。
4、可抢占优先权调度在这种方式下,系统把处理机分配给优先权最高的进程,使之执行。
但在其执行期间,只要出现另一个其优先权更高的进程,进程调度程序就立即停止当前进程(原优先权最高的进程)的执行,重新将处理及分配给新到的优先权最高的进程。
四、程序流程图。
1、可抢占优先权调度算法2、FCFS3、非抢占SJF五、程序部分1、FCFS#include<stdio.h>#include<stdlib.h>typedef struct PCB{char name[10];char state;int arrivetime;int starttime;int finishtime;int servicetime;float turnaroundtime;float weightedturnaroundtime;struct PCB *next;}pcb;int time;int n;pcb *head=NULL,*p,*q;void run_fcfs(pcb *p1){time=p1->arrivetime>time?p1->arrivetime:time;p1->starttime=time;printf("\n现在时间是%d,开始运行作业%s\n",time,p1->name);time+=p1->servicetime;p1->state="T";p1->finishtime=time;p1->turnaroundtime=p1->finishtime-p1->arrivetime;p1->weightedturnaroundtime=p1->turnaroundtime/p1->servicetime;printf(" 到达时间开始时间服务时间完成时间周转时间带权周转时间\n ");printf("%6d%10d%10d%8d%10.1f%10.2f\n",p1->arrivetime,p1->starttime,p1->servicetime,p1->finishtime,p1->turnaroundtime,p1->weightedtu rnaroundtime);}void fcfs(){int i,j;p=head;for(i=0;i<n;i++){if(p->state=='F'){q=p;run_fcfs(q);}p=p->next;}}void getInfo(){int num;printf("\n作业个数:");scanf("%d",&n);for(num=0;num<n;num++){p=(pcb*)malloc(sizeof(pcb));printf("依次输入:进程名到达时间服务时间\n");scanf("%s%d%d",&p->name,&p->arrivetime,&p->servicetime);if(head==NULL){head=p;q=p;time=p->arrivetime;}if(p->arrivetime<time)time=p->arrivetime;q->next=p;p->starttime=0;p->finishtime=0;p->turnaroundtime=0;p->weightedturnaroundtime=0;p->next=NULL;p->state='F';q=p;}}void main(){ system("graftabl 936");printf("先来先服务算法模拟");getInfo();p=head;fcfs();getch();}2、非抢占SJF#include<stdio.h>#include<conio.h>#define MAX 100struct jcb{char name[10];float arrivetime;float starttime;float finishtime;float servicetime;float zztime;float avezztime;};struct jcb a[MAX];void input(jcb *p,int N){ int i;printf("请分别输入\n\t进程名到达时间服务时间\n\n");for(i=0;i<=N-1;i++){printf("请输入第%d个进程信息:",i+1);scanf("%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].servicetime);printf("\n");}}void Print(jcb *p, float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float avezztime,int N){int k;printf("调度顺序:");printf("%s",p[0].name);for(k=1;k<N;k++){printf("-->%s",p[k].name);}printf("\n\n");printf("\t\t\t进程信息:\n");printf("\nname\tarrive\tservice\tstart\tfinish\tzz\tavezz\n");for(k=0;k<=N-1;k++){printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n",p[k].name,p[k].arrivetime,p[k].serviceti me,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].avezztime);}}void sort(jcb *p,int N){int i,j;for(i=0;i<=N-1;i++)for(j=0;j<=i;j++)if(p[i].arrivetime<p[j].arrivetime){jcb temp;temp=p[i];p[i]=p[j];p[j]=temp;}}void deal(jcb *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &avezztime,int N){int k;for(k=0;k<=N-1;k++){if(k==0){p[k].starttime=p[k].arrivetime;p[k].finishtime=p[k].arrivetime+p[k].servicetime;}else{p[k].starttime=p[k-1].finishtime;p[k].finishtime=p[k-1].finishtime+p[k].servicetime;}}for(k=0;k<=N-1;k++){p[k].zztime=p[k].finishtime-p[k].arrivetime;p[k].avezztime=p[k].zztime/p[k].servicetime;}}void jcbf(jcb *p,int N){ float arrivetime=0, servicetime=0, starttime=0, finishtime=0, zztime=0, avezztime=0; int m,n,next,k,i=0;float min;sort(p,N);for(m=0;m<N-1;m++){if(m==0)p[m].finishtime=p[m].arrivetime+p[m].servicetime;elsep[m].finishtime=p[m-1].finishtime+p[m].servicetime;for( n=m+1;n<=N-1;n++){if(p[n].arrivetime<=p[m].finishtime)i++;}min=p[m+1].servicetime;next=m+1;for(k=0;k<m+i;k++){if(p[k+1].servicetime<min){min=p[k+1].servicetime;next=k+1;}}{jcb temp;temp=p[m+1];p[m+1]=p[next];p[next]=temp;}deal(p,arrivetime,servicetime,starttime,finishtime,zztime,avezztime,N);Print(p,arrivetime,servicetime,starttime,finishtime,zztime,avezztime,N);}}int main(){int N,*b; char ch;while(1){system("CLS");system("graftabl 936");printf("\t\t\t------短作业优先调度算法------\n");printf("输入进程个数:");scanf("%d",&N);if(N>MAX){printf("\t!!输入的作业数目太大,请输入不大于%d的整数\n",MAX);printf("按Q或者q退出程序,按其他任意键继续测试...");ch=getch();if(ch=='Q'||ch=='q'){break;}else continue;}input(a,N);jcb *b=a;jcbf(b,N);printf("按Q或者q退出程序,按其他任意键继续测试...");ch=getch();if(ch=='Q'||ch=='q'){}}return 0;getch();}3、可抢占优先权调度算法#include<dos.h>#include<time.h>#include<stdlib.h>#include<stdio.h>#include<conio.h>#include<string.h>typedef char string[10];struct task{string name;int arrTime;int serTime;int waiTime;int begTime;int finTime;int turTime;int wTuTime;int priority;int finish;}JCB[10];int num;void input(){int i;system("cls");printf("\n请输入作业数量:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n请输入作业NO.%d:\n",i);printf("作业名称:");scanf("%s",JCB[i].name);printf("到达时间:");scanf("%d",&JCB[i].arrTime);printf("服务时间:");scanf("%d",&JCB[i].serTime);JCB[i].priority=0;JCB[i].finish=0;}}int HRN(int pre){int current=1,i,j;for(i=0;i<num;i++){JCB[i].waiTime=JCB[pre].finTime-JCB[i].arrTime;JCB[i].priority=(JCB[i].waiTime+JCB[i].serTime)/JCB[i].serTime; }for(i=0;i<num;i++){if(!JCB[i].finish)current=i;break;}}for(j=i;j<num;j++){if(!JCB[j].finish){if(JCB[current].arrTime<=JCB[pre].finTime){if(JCB[j].arrTime<=JCB[pre].finTime&&JCB[j].priority>JCB[current].priority)current=j;}else{if(JCB[j].arrTime<JCB[current].arrTime)current=j;if(JCB[j].arrTime==JCB[current].arrTime)if(JCB[j].priority>JCB[current].priority)current=j;}}}return current;}void runing(int i,int times,int pre,int staTime,int endTime){if(times=0){JCB[i].begTime=JCB[i].arrTime;JCB[i].finTime=JCB[i].begTime+JCB[i].serTime;JCB[i].turTime=JCB[i].serTime;JCB[i].wTuTime=1.0;staTime=JCB[i].begTime;}else{if(JCB[i].arrTime>JCB[pre].finTime)JCB[i].begTime=JCB[i].arrTime;elseJCB[i].begTime=JCB[pre].finTime;JCB[i].finTime=JCB[i].begTime+JCB[i].serTime;JCB[i].turTime=JCB[i].finTime-JCB[i].arrTime;JCB[i].wTuTime=JCB[i].turTime/JCB[i].serTime;}if(times==num-1)endTime=JCB[i].finTime;JCB[i].finish=1;}void print(int i,int times){if(times==0){printf("名称到达时间服务时间开始时间完成时间周转时间带权周转时间\n");}printf("%3s%9d%9d%9d%9d%9d%9d\n",JCB[i].name,JCB[i].arrTime,JCB[i].serTime,JCB[i].be gTime,JCB[i].finTime,JCB[i].turTime,JCB[i].wTuTime);}void check(){int i;int staTime,endTime,sumTurTime=0.0,sumWTuTime=0.0,aveturTime,aveWTuTime;int current=0,times=0,pre=0;JCB[pre].finTime=0;for(i=0;i<num;i++){JCB[i].finish=0;}staTime,endTime,sumTurTime=0.0,sumWTuTime=0.0,aveturTime,aveWTuTime;current=0;times=0;pre=0;printf("-------------------------------------------\n");for(i=0;i<num;i++){JCB[i].finish=0;}staTime,endTime,sumTurTime=0.0,sumWTuTime=0.0,aveturTime,aveWTuTime;current=0;times=0;pre=0;printf("-------HRRN-------------------------------------\n");for(times=0;times<num;times++){current=HRN(pre);runing(current,times,pre,staTime,endTime);print(current,times);pre=current;}for(i=0;i<num;i++){sumTurTime+=JCB[i].turTime;sumWTuTime+=JCB[i].wTuTime;}aveturTime=sumTurTime/num;aveWTuTime=sumWTuTime/num;printf("<计与平均值>%9d%9d%9d%9d\n",NULL,sumTurTime,aveturTime,aveWTuTime);printf("-------------------------------------------------------\n");}void main(){char again;system("graftabl 936");do{system("cls");printf("请输入4组数据:");input();check();printf("Continue...(Y/N):");do{again=getch();}while(again!='Y'&&again!='y'&&again!='N'&&again!='n');}while(again=='Y'||again=='y');getch();}六、运行结果七、实验总结1、FCFS算法,即先来先服务,就是每次从就绪队列中选择一个最先进入队列的进程,把CPU分配给它,令它运行。