非抢占式EDF算法下周期性任务的最小相对截止期计算
EDF调度算法
2 1)
Page 9
一、引入 2、国内外研究概况
当然，RM是基于这样一种比较理想的硬实时周期任务模型： i. 所有的任务都是周期任务 ii. 所有的任务都是不相关的，即它们没有共享资源 iii.所有任务都有一个固定的执行时间或最大执行时间 iv.所有任务的相对截止时间 都等于它们的周期 v. 所有任务都是可抢占的 vi.系统只有一个处理器 注：若iv不成立，则RM不是最优的固定优先级调度算法。这 事可采用另一种算法：时限单调(deadline monotonic)调度算 法DM，其按任务的相对时限来分配优先级：相对时限越短， 优先级越高。
Page 12
一、引入 2、国内外研究概况
软实时任务和偶发任务的调度 因为软实时任务允许运行时间错过截止期，所以其调度目标 是在保证满足硬实时周期任务的时限前提下，提高软实时任 务的响应时间。目前主要的调度算法有：
i. 后台运行法
ii. 轮询服务器法 iii. 挪用法
Page 13
一、引入 2、国内外研究概况
Page 11
一、引入 2、国内外研究概况
还有其他的动态优先级调度算法，e.g 最小空闲时间优先 （Least Slack Time First,LST）算法。
一个任务在t时刻的空闲时间等于： 截止时刻－ t －该任务的剩余执行时间
虽然LST也是具有最优性ቤተ መጻሕፍቲ ባይዱ但需随时监视所有就绪任务，运行 时的开销较大，且如果两个任务的空闲时间接近，很容易产生 调度的颠簸现象，所以实际使用中一般不适用。
Page 5
一、引入 1、背景、目的及意义
从实时系统理论的发展来看，主要有以下几个方面： 有资源互斥的硬实时任务调度： 提出几种资源互斥协议来防止优先级反转和死锁问题， 并给出相应的可调度判定条件。 多处理器实时任务调度，前面的研究都是假定系统中只有 一个处理器，忽略实际复杂的因素，将注意力集中到调度算 法、资源访问控制和可调度性分析判定的基本原理上。这部 分将这些理论应用于包含多个处理器的实时系统中，并处理 在单处理器系统中未出现的问题。
EDF可调度性证明
即存在 中任务的一组释放时刻( 的作业在时刻0释放，而其他任务的作业均在时刻 释放)，使得 ，与 可调度矛盾。
故必要性成立，即如果 在不可抢占式EDF调度算法下可调度，以上条件总成立，再证充分性。
(1)
(2)
该判定条件仅限于任务的截止期等于其周 Nhomakorabea的情况。在截止期不等于其周期的情况下，以上判定条件并不适用。
定理1：令周期性硬实时任务集 ，其中， 为任务 的最坏执行时间。 为任务 的周期， 为任务 的截止期．则当且仅当以下条件成立， 在不可抢占式EDF调度算法下可调度：
其中， 。
证明：
先证必要性。假设存在一个周期性硬实时任务集 ， 在不可抢占式EDF调度算法下可调度，但不满足条件，即 ，使得 ，其中 。令 ，其 中。
情形1：截止期大于 的所有作业在[ , ]内均未被调度执行，即[ , ]内得到调度的作业均是截止期小于或等于 的。
情形2：存在着某个(或某些)截止期大于 的作业在[ , ]内被调度执行。
以下将分别按这两种情形来讨论。
情形1：因有任务在 错过截止期，故 。由式(2)有：
由于 为空闲区间的结束时刻，所以[ , ]区间内调度的作业都在 或者 后被释放，且[ , ]内调度的作业其截止期小于或等于 ，即存在作业在[ , ]内释放，又在[ , ]内到达截止期，所以 。
EDF算法可调度性证明
截止期最早的任务优先调度(Earliest Deadline First，EDF)算法。该算法规定任务的截止期限越小，优先级越高。EDF调度又可以分为可抢占模式和不可抢占模式。但如果基于不可抢占模式实现EDF算法，调度的开销要远小于可抢占模式。故而只讨论不可抢占EDF调度算法。
操作系统期末考试试卷
操作系统期末考试试卷0250-0252操作系统试卷A0250—0252操作系统试卷A一、简答题（每题5分，共30分）1。
什么是虚拟设备？2。
What’s the differrence between a process and a program？3。
What’s Hyper—Treading technology？4.死锁的必要条件是什么？5.为什么将文件控制块分成主部和次部两部分？6.若系统有同类资源m个,被n个进程共享，问：当m〉n和m〈=n时每个进程最多可以请求多少个这类资源，使系统一定不会发生死锁？为什么?二、填空题(每空1分，共10分)1.操作系统的两个重要特性是：(1) 和（2） .2。
只能在管态下执行的指令称为(3) .处理机状态由目态转换为管态的唯一途径是(4），管态到目态的转换可以通过修改（5) 来实现。
3.进程在其生存期内可以处于如下三种基本状态之一：运行态、就绪态和等待态。
当一个就绪进程（6）时，其状态由就绪变为运行,当一个运行进程被抢占处理机时，其状态由运行变为（7) ,当一个运行进程因某事件受阻时，其状态由运行变为(8) ，当进程所等待的事件已经发生时,该进程状态由（9) 变为就绪。
4。
线程是进程内的一个相对独立的(10）.三、计算题（每题10分，共40分)1.设某计算机系统采用虚拟页式存储管理方法，进程的虚拟地址空间为64KB,页面尺寸为4KB。
假设当前进程的页表如右图所示（页表以二进制形式表示），请将虚拟地址8196和2050转换为物理地址。
2。
设某计算机系统采用虚拟页式存储管理方法，内存中为该进程分配4个物理页架，开始时内存页架为空,假设进程在一段时间内的页面访问序列如下:6,0,1，2,0,3，0,4，2，3，0，3，2，1，2,0,1,7,0，1，请画图表示采用以下页面淘汰算法时的缺页中断次数:(1）最佳页面淘汰算法（OPT)；（2)先进先出页面淘汰算法（FIFO）；（3)使用过最久的先淘汰(LRU）。
嵌入式实时操作系统试题
嵌⼊式实时操作系统试题1、⽬前使⽤的嵌⼊式操作系统主要有那些？请举出六种常⽤的。
Windwos CE、Windows Mobile、VxWork、Linux、uCos、Symbian、QNX2、⼀般⽽⾔，嵌⼊式系统的架构可以分为4个部分，分别是（处理器）、存储器、输⼊输出和软件，⼀般软件分为（操作系统）和应⽤软件两个主要部分。
3、从嵌⼊式操作系统特点可以将嵌⼊式操作系统分为（实时操作系统）和分时操作系统，其中实时系统可分为（硬实时系统）和软实时系统4、uc/os操作系统不包括以下哪集中状态A、运⾏B、挂起C、退出D、休眠5、0x70&0x11的运算结果是A、0x1B、0x11C、0x17D、0x76、下列哪种⽅式不是ucos操作系统中任务之间的通信⽅式A、信号量B、消息队列C、邮件D、邮箱7、在将ucos操作系统移植到ARM处理器上时，以下那些⽂件不需要修改A、OS_CORE.CB、include.hC、OS_CPU.HD、OSTaskInit设计实时操作系统时，⾸先应该考虑系统的（）。
A．可靠性和灵活性B．实时性和可靠性C．分配性和可靠性D．灵活性和实时性2. ⼤多数嵌⼊式实时操作系统中，为了让操作系统能够在有突发状态时迅速取得控制权，以作出反映，⼤都采⽤（）的功能。
A:抢占式任务调度B:时间⽚轮转调度C:单调速率调度D:FIFO调度8、所有的电⼦设备都属于嵌⼊式设备简单题：1、根据嵌⼊式系统的特点、写出嵌⼊式系统的定义答：以应⽤为中⼼，以计算机技术为基础，软硬件可裁剪、功能、可靠性、成本、体积、功耗严格要求的专⽤计算机系统2、试分析实时操作系统的⼯作特点及相互之间的转换运⾏：获得CPU的控制权就绪：进⼊任务等待队列，通过调度中转为运⾏状态挂起：由于系统函数调⽤⽽被设置成挂起状态，任务发⽣阻塞，等待系统实时事件的发⽣⽽被唤醒，从⽽转为就绪或运⾏。
休眠：任务完成或者错误被清除的任务，该任务此时不具有任务控制块。
最早期限优先调度算法(EDF)实验报告
实验报告实验名称：最早期限优先调度算法（EDF）实验一、实验目的1）了解实时调度，了解最早截止期优先算法（EDF算法）；2）使用C语言实现最早截止期优先算法（EDF算法）；3）计算多个任务的调度顺序。
二、实验原理最早截止期优先算法（EDF），也称为最早死限调度算法（DDS），是一种采用动态调度的优先级调度算法，任务的优先级根据任务的截止时间来确定。
任务的截止时间越近，任务的优先级越高；任务的截止时间越远，任务额优先级越低。
当有新的任务处于就绪状态时，任务的优先级就有可能需要进行调整。
EDF算法的测试如果所有的任务都是周期性的，并且对应的时间限等于它们的周期，对任务集的调度性的测试是非常简单的：如果任务集的总利用率不大于1，那么任务集就可以由EDF算法在一个单处理器上进行合理的调度。
对于那些任务的时间限并不全等于其周期的情况，没有简答的调度性测试。
在这样的情况下，需要使用EDF算法生成一个时间表，来判断是不是在一个给定的时间区间内所有的时间限都被满足。
在这种情况下EDF的一个可调度性测试如下：定义，以及（这里的“lcm”表示最小公倍数）。
定义是任务集T中所有满足其时间限的绝对值小鱼t的任务执行时间之和。
一个由n个任务构成的集合不是可行的EDF的充分必要条件是：或存在某个使得（其中n为任务集中任务的数量；为任务的执行时间；为周期任务的周期；为任务的相对时间限；为在绝对时间不迟于t的任务集合T中，所有重复的任务执行时间和。
）三、实验仪器硬件：PC机；软件：Windows7，Visual Studio 2010集成开发环境四、实验步骤1）理解EDF调度算法的原理并通过实例用EDF算法判断多任务的调度顺序。
2）新建EDF.h 头文件，在其中定义变量，结构体，函数。
3）新建input.c文件，用input函数从键盘获取多个任务的名称、执行时间、周期和释放时间，将任务分成一个个时间片存在数组中，并输出数组和各时间片属性。
计算机操作系统(第3版)课后习题答案(完整版)
4
1 1．试说明引起进程创建的主要事件。 答：引起进程创建的主要事件有：用户登录、作业调度、提供服务、应用请求。 1 2．试说明引起进程被撤销的主要事件。 答：引起进程被撤销的主要事件有：正常结束、异常结束（越界错误、保护错、非法指令、 特权指令错、运行超时、等待超时、算术运算错、I/O 故障）、外界干预（操作员或操作 系 统干预、父进程请求、父进程终止）。 1 3．在创建一个进程时所要完成的主要工作是什么？ 答： （1）OS 发现请求创建新进程事件后，调用进程创建原语Creat()； （2）申请空白PCB； （3）为新进程分配资源； （4）初始化进程控制块； （5）将新进程插入就绪队列. 1 4．在撤销一个进程时所要完成的主要工作是什么？ 答： （1）根据被终止进程标识符，从PCB 集中检索出进程PCB，读出该进程状态。 （2）若被终止进程处于执行状态，立即终止该进程的执行，置调度标志真，指示该进程被 终止后重新调度。 （3）若该进程还有子进程，应将所有子孙进程终止，以防它们成为不可控进程。 （4）将被终止进程拥有的全部资源，归还给父进程，或归还给系统。 （5）将被终止进程PCB 从所在队列或列表中移出，等待其它程序搜集信息。 1 5．试说明引起进程阻塞或被唤醒的主要事件是什么？ 答：a. 请求系统服务；b. 启动某种操作；c. 新数据尚未到达；d. 无新工作可做. 1 6．进程在运行时存在哪两种形式的制约？并举例说明之。 答： （1）间接相互制约关系。举例：有两进程A 和B，如果A 提出打印请求，系统已把唯一的 一台打印机分配给了进程B，则进程A 只能阻塞；一旦B 释放打印机，A 才由阻塞改为就 绪。 （2）直接相互制约关系。举例：有输入进程A 通过单缓冲向进程B 提供数据。当缓冲空时， 计算进程因不能获得所需数据而阻塞，当进程A 把数据输入缓冲区后，便唤醒进程B；反 之，当缓冲区已满时，进程A 因没有缓冲区放数据而阻塞，进程B 将缓冲区数据取走后便 唤醒A。 1 7．为什么进程在进入临界区之前应先执行 “进入区”代码？而在退出前又要执行 “退出 区”代码？ 答：为了实现多个进程对临界资源的互斥访问，必须在临界区前面增加一段用于检查欲访问 的临界资源是否正被访问的代码，如果未被访问，该进程便可进入临界区对资源进行访问， 并设置正被访问标志，如果正被访问，则本进程不能进入临界区，实现这一功能的代码为" 进入区"代码；在退出临界区后，必须执行" 退出区"代码，用于恢复未被访问标志，使其它 进程能再访问此临界资源。 18. 同步机构应遵循哪些基本准则？为什么？ 答：同步机构应遵循的基本准则是：空闲让进、忙则等待、有限等待、让权等待 原因：为实现进程互斥进入自己的临界区。 19. 试从物理概念上说明记录型信号量wait 和signal。
最早期限优先调度算法(EDF)实验报告材料
实验报告实验名称：最早期限优先调度算法（EDF ）实验一、 实验目的1） 了解实时调度，了解最早截止期优先算法（EDF 算法）；2） 使用C 语言实现最早截止期优先算法（EDF 算法）； 3） 计算多个任务的调度顺序。
二、 实验原理最早截止期优先算法（EDF ），也称为最早死限调度算法（DDS ），是一种采用动态调度的优先级调度算法，任务的优先级根据任务的截止时间来确定。
任务的截止时间越近，任务的优先级越高；任务的截止时间越远，任务额优先级越低。
当有新的任务处于就绪状态时，任务的优先级就有可能需要进行调整。
EDF 算法的测试如果所有的任务都是周期性的，并且对应的时间限等于它们的周期，对任务集的调度性的测试是非常简单的：如果任务集的总利用率不大于1，那么任务集就可以由EDF 算法在一个单处理器上进行合理的调度。
对于那些任务的时间限并不全等于其周期的情况，没有简答的调度性测试。
在这样的情况下，需要使用EDF 算法生成一个时间表，来判断是不是在一个给定的时间区间所有的时间限都被满足。
在这种情况下EDF 的一个可调度性测试如下：定义u =∑(e i /P i )n i=1，d max =max 1≤i≤n{d i }以及P =lcm(P 1,…Pn )（这里的“lcm ”表示最小公倍数）。
定义ℎT (t)是任务集T 中所有满足其时间限的绝对值小鱼t 的任务执行时间之和。
一个由n 个任务构成的集合不是可行的EDF 的充分必要条件是：u >1或存在某个t <min{P +d max ,u1−u max 1≤i≤n{P i −d i }} 使得ℎT (t )>t（其中n 为任务集中任务的数量；e i 为任务T i 的执行时间；P i 为周期任务的周期；d i 为任务T i 的相对时间限；ℎT (t )为在绝对时间不迟于t 的任务集合T 中，所有重复的任务执行时间和。
）三、 实验仪器硬件：PC 机；软件：Windows7，Visual Studio 2010集成开发环境四、实验步骤1）理解EDF调度算法的原理并通过实例用EDF算法判断多任务的调度顺序。
一种基于EDF的实时任务调度算法浅析
一种基于EDF的实时任务调度算法浅析一种基于EDF的实时任务调度算法浅析摘要实时系统的高可靠性、计算准确性及输出结果的实时性使得其在各领域的应用越来越广泛。
而实时调度算法是实时系统中的关键技术。
本文在EDF 算法的基础上提出了一种新的实时调度算法，该算法通过任务的可推迟执行时间逐次逼近，能够快速准确的计算出每个任务的最大可挪用时间。
关键词实时性；实时调度算法；单调速率优先；最早截止期优先；计算时间前言实时系统是指能够及时响应外部发生的随机事件，并在规定时间内完成对事件处理的计算机系统。
实时系统具有高可靠性、实时性、少人工干预、专用性等特征，广泛应用于航天控制、工业控制、机器人智能控制、云计算、多处理器下多媒体流调度以及嵌入式智能设备等各个重要领域。
实时系统不仅应用广泛，而且要求严格。
对实时调度算法的研究，是实时领域的一个重要的研究课题[1]。
1 实时调度算法实时调度算法可以分为两类：静态调度算法和动态调度算法。
RM 和EDF 调度算法分别是经典的静态和动态实时高度算法，在实时调度领域占有重要地位。
EDF调度算法按照实时任务截止期的远近来分配优先级，截止期越近的任务优先级越高，任何时刻总是运行优先级最高的任务，即总是优先运行最紧迫的任务。
因为在不同时刻，两个周期任务截止期的远近关系可能会改变，所以EDF 调度算法是一种动态优先级调度算法。
EDF算法不仅对于硬实时周期任务调度，而且对于硬实时非周期任务的调度来说都是最优的动态优先级调度算法本文在EDF算法的基础上提出了一种新的实时调度算法，该算法通过任务的可推迟执行时间逐次逼近，能够快速准确的计算出每个任务的最大可挪用时间[2]。
2 任务模型本文使用以下概念来描述实时系统。
定义1（超周期，hyperperiod）：硬实时周期任务集中的所有任务周期的最小公倍数，记为H，H=LCM（T1，T2，…，Tn），其中LCM是最小公倍数函数。
定义2（周期任务的负载）：一个周期任务平均对处理器的占用率，记为u，u=C/T，C为周期任务每次的执行时间，T为周期任务的周期，即每次释放的时间间隔。
edf算法在linux内核中的实践研究
edf算法在linux内核中的实践研究EDF（Earliest Deadline First）算法是一种实时调度算法，用于根据任务的截止时间进行调度。
在 Linux 内核中，EDF 调度算法主要应用于实时任务的调度。
Linux 内核中的实时调度器主要有两种：CFS（Completely Fair Scheduler）和SCHED_DEADLINE。
其中，SCHED_DEADLINE 是实时调度器的一种扩展，提供了对实时任务的支持，包括使用EDF 调度算法对实时任务进行调度。
SCHED_DEADLINE 调度策略下的任务可以通过设置参数来指定任务的截止时间和期限。
在这种调度策略下，Linux 内核使用EDF 调度算法将任务按照截止时间的先后顺序进行调度，确保截止时间更早的任务优先被执行。
对于周期性任务，Linux 内核提供了 sched_setscheduler() 系统调用来设置任务的调度策略和相关参数。
在调用该系统调用时，可以指定任务的调度策略为 SCHED_DEADLINE，然后设置相关的截止时间和期限等参数。
Linux 内核会根据设置的参数使用 EDF 调度算法进行实时任务的调度。
通过使用 EDF 调度算法，Linux 内核能够更好地保证实时任务的截止时间得到满足，并提高实时任务的响应能力和可靠性。
这对于一些对响应时间要求较高的应用场景非常重要，比如嵌入式系统、工控系统等。
总之，EDF 算法在 Linux 内核中通过 SCHED_DEADLINE 调度策略的实现，提供了对实时任务的支持，并根据任务的截止时间进行调度。
它在提高实时任务的响应能力和可靠性方面具有重要的实践研究意义。
实时调度算法之EDF算法
实时调度算法之EDF算法实时调度算法之EDF算法(Earliest Deadline First)是一种常见的实时任务调度算法，其核心思想是根据任务的最早截止时间来进行任务的调度。
EDF算法首先将任务按照截止时间从小到大排序，然后优先调度具有最早截止时间的任务，以保证任务的截止时间得到满足。
EDF算法的主要步骤如下：1.初始化：将所有的实时任务按照截止时间从小到大排序，初始化系统时钟。
2.选择任务：选择具有最早截止时间的任务进行调度。
3.执行任务：执行所选任务，直到完成或者到达截止时间。
4.更新截止时间：如果任务未完成，则将其截止时间向后移动。
5.返回步骤2在EDF算法中，任务截止时间的选择是至关重要的。
如果存在截止时间无法满足的情况，则系统可能出现任务丢失，导致严重的系统错误。
因此，在设计实时任务系统时，需要合理设置任务的截止时间，以保证任务能够按时完成。
EDF算法的优点是能够满足任务的截止时间要求，具有较高的实时性，适用于对任务响应时间要求较高的场景。
另外，EDF算法可以充分利用系统资源，提高系统的利用率。
然而，EDF算法也存在一些限制和挑战。
首先，EDF算法对任务的截止时间要求较高，如果任务的截止时间无法准确设置，可能导致系统性能下降。
其次，EDF算法无法处理任务的优先级，无法保证低优先级任务的执行。
因此，EDF算法主要适用于任务优先级相同，或者任务的截止时间能够准确设置的场景。
在实际应用中，为了提高EDF算法的性能和可靠性，通常会采取一些优化措施。
例如，引入抢占式调度，通过中断等方式中断当前任务的执行，切换到具有更早截止时间的任务上。
此外，还可以根据任务的执行时间和截止时间间隔，动态调整任务的优先级，以提高系统的负载能力和资源利用率。
总之，EDF算法是一种基于最早截止时间的实时任务调度算法，能够保证任务截止时间的满足，具有较高的实时性和性能。
通过合理设置任务的截止时间和采取优化措施，可以进一步提高EDF算法的性能和可靠性。
非抢占式高优先级调度算法
/*非抢占式高优先级调度算法（优先数越大级别越高）算法思想：在按进程达到时间由小到大的顺序输入进程信息后，先对其优先数进行排列，将最先到达的进程的到达时间设为开始时间，计算结束时间，然后对后面到达的时间与该进程的结束时间进行比较，如若小于该进程的结束时间，记录进程的个数，再对其优先数逐个进行比较，将优先数最大的提到前面，每次进程结束都要进行比较，得到执行序列，在依次输出结果*/#include<stdio.h>#define MAX 100struct hrfs{char name[10];float arrvitetime;float starttime;float servietime;float finishtime;int priority;//优先数int order;//进程执行次序int run_flag;//标记进程状态};hrfs p[MAX];int count;//排列到达时间//按到达时间与优先数计算执行序列void HRfs(){float temp_time=0;int i=0,j;int k,temp_count;int max_priority;max_priority=p[i].priority;j=1;while((j<count)&&(p[i].arrvitetime==p[j].arrvitetime)){if(p[j].priority>p[i].priority){max_priority=p[j].priority;i=j;}j++;}k=i;p[k].starttime=p[k].arrvitetime;//开始时间=达到时间p[k].finishtime=p[k].starttime+p[k].servietime;p[k].run_flag=1;temp_time=p[k].finishtime;p[k].order=1;temp_count=1;while(temp_count<count){max_priority=0;for(j=0;j<count;j++){//判断到达时间是否小于上一个进程的结束时间并且非处在运行状态if((p[j].arrvitetime<=temp_time)&&(!p[j].run_flag))//判断进程优先数是否大于最大优先数，如果大于，就将其值赋给max_priorityif(p[j].priority>max_priority){max_priority=p[j].priority;k=j;}}p[k].starttime=temp_time;p[k].finishtime=p[k].starttime+p[k].servietime;p[k].run_flag=1;temp_time=p[k].finishtime;temp_count++;p[k].order=temp_count;}}void input(){int i;printf("\n请输入进程名到达时间运行时间优先数，例如：a 0 100 1\n");for(i=0;i<count;i++){printf("进程%d的信息:",i+1);scanf("%s%f%f%d",p[i].name,&p[i].arrvitetime,&p[i].servietime,&p[i].priority);p[i].starttime=0;p[i].finishtime=0;p[i].order=0;p[i].run_flag=0;}}void print(){int i;float turn_round_time=0,f1,w=0;float right_turn_round_time;printf("\n-------------------------------进程完成信息------------------------------------\n");printf("进程名优先级达到时间运行时间开始时间结束时间周转时间带权周转时间运行次序\n");for(i=0;i<count;i++){f1=p[i].finishtime-p[i].arrvitetime;turn_round_time+=f1;right_turn_round_time=f1/p[i].servietime;w+=(f1/p[i].servietime);printf("%s %5d %10.2f %8.2f %8.2f %8.2f %8.2f %8.2f %8d\n",p[i].name,p[i].priority,p[i].a rrvitetime,p[i].servietime,p[i].starttime,p[i].finishtime,f1,right_turn_round_time,p[i].order);}printf("平均周转时间=%5.2f\n",turn_round_time/count);printf("平均带权周转时间=%5.2f\n",w/count);}void main(){printf("---------------------------非抢占式高优先级调度算法----------------------------\n");printf("进程个数:");scanf("%d",&count);input();HRfs();print();}。
python实现的EDF（earliestdeadlinefirst）算法
python实现的EDF（earliestdeadlinefirst）算法1. 最早截⽌时间优先EDF（Earliest DeadlineFirst）算法是⾮常著名的实时调度算法之⼀。
在每⼀个新的就绪状态，调度器都是从那些已就绪但还没有完全处理完毕的任务中选择最早截⽌时间的任务，并将执⾏该任务所需的资源分配给它。
在有新任务到来时，调度器必须⽴即计算EDF，排出新的定序，即正在运⾏的任务被剥夺，并且按照新任务的截⽌时间决定是否调度该新任务。
如果新任务的最后期限早于被中断的当前任务，就⽴即处理新任务。
按照EDF算法，被中断任务的处理将在稍后继续进⾏。
2. 该算法的思想是从两个任务中选择截⾄时间最早的任务,把它暂作为当前处理任务,再判断该任务是否在当前周期内,若不在当前周期内,就让另⼀任务暂作当前处理任务,若该任务也不在当前周期内,就让CPU空跑到最靠近的下⼀个截⾄时间的开始,若有任务在该周期内,就判断该任务的剩余时间是否⼩于当前截⾄时间与当前时间的差,若⼩于,则让该任务运⾏到结束.否则,就让该任务运⾏到该周期的截⽌时间,就⽴即抢回处理器,再判断紧接着的最早截⾄时间,并把处理器给它,做法同上,如此反复执⾏.1#!/user/bin/env python2# -*- coding:utf-8 -*-345class GetCloseTime:6def__init__(self, dictionary):7 self.dictionary = dictionary89def greatest_common_divisor(self, _left, _right):10return _left if _right == 0 else self.greatest_common_divisor(_right, _left % _right)1112def lowest_common_multiple(self):13 temp_result = 114for value in self.dictionary.values():15 temp_result = value[1] * temp_result / self.greatest_common_divisor(value[1], temp_result)16return temp_result171819class TaskControlBlock:20 CURRENT_TIME = 02122def__init__(self, dictionary,23 name_list,24 period_time,25 central_processing_unit_time,26 remain_time,27 current_period):28for key in dictionary.keys():29 name_list.append(key)30 period_time.append(dictionary.get(key)[1])31 central_processing_unit_time.append(dictionary.get(key)[0])32 remain_time.append(dictionary.get(key)[0])33 current_period.append(1)3435def get_index_of_min(self, earliest_deadline_task_list, minimum):36return earliest_deadline_task_list.index(minimum)3738def get_another_index_of_min(self, earliest_deadline_task_list, minimum):39 earliest_deadline_task_list[earliest_deadline_task_list.index(minimum)] = 10000040return earliest_deadline_task_list.index(min(earliest_deadline_task_list))4142def is_execute(self, central_processing_unit_time, period_time):43 temp_list = [a / b for a, b in zip(central_processing_unit_time, period_time)]44return sum(temp_list)4546def scheduling(self, name_list,47 period_time,48 central_processing_unit_time,49 remain_time,50 current_period):51if self.is_execute(central_processing_unit_time, period_time) > 1:52print("error, scheduling finish!")53 exit(0)54 earliest_deadline_task = self.get_index_of_min(55 [a * b for a, b in zip(period_time, current_period)],56 min(a * b for a, b in zip(period_time, current_period)))5758if self.CURRENT_TIME < period_time[earliest_deadline_task] * (current_period[earliest_deadline_task] - 1):59 current_period_p = period_time[earliest_deadline_task] * (current_period[earliest_deadline_task] - 1)60 temp_list = [a * b for a, b in zip(period_time, current_period)]61while self.CURRENT_TIME < period_time[earliest_deadline_task] * \62 (current_period[earliest_deadline_task] - 1):63 earliest_deadline_task = self.get_another_index_of_min(temp_list, min(temp_list))6465if remain_time[earliest_deadline_task] <= current_period_p - self.CURRENT_TIME:66 running_time = remain_time[earliest_deadline_task]67else:68 running_time = current_period_p - self.CURRENT_TIME69# current_period_p = period_time[earliest_deadline_task] * current_period[earliest_deadline_task] 70 remain_time[earliest_deadline_task] -= running_time71print(name_list[earliest_deadline_task], self.CURRENT_TIME, running_time)72 self.CURRENT_TIME += running_time73if remain_time[earliest_deadline_task] == 0:74 current_period[earliest_deadline_task] += 175 remain_time[earliest_deadline_task] = central_processing_unit_time[earliest_deadline_task] 76else:77 current_period_p = period_time[earliest_deadline_task] * current_period[earliest_deadline_task] 78if remain_time[earliest_deadline_task] <= current_period_p - self.CURRENT_TIME:79 running_time = remain_time[earliest_deadline_task]80else:81 running_time = current_period_p - self.CURRENT_TIME82 remain_time[earliest_deadline_task] -= running_time83print(name_list[earliest_deadline_task], self.CURRENT_TIME, running_time)84 self.CURRENT_TIME += running_time85if remain_time[earliest_deadline_task] == 0:86 current_period[earliest_deadline_task] += 187 remain_time[earliest_deadline_task] = central_processing_unit_time[earliest_deadline_task] 888990if__name__ == "__main__":91 task_dictionary = {"A": [10, 30],92"B": [20, 60],93"C": [30, 90]}94 close_time_object = GetCloseTime(task_dictionary)95 close_time = close_time_object.lowest_common_multiple()9697 current_time = 098 name_list = []99 period_time = []100 central_processing_unit_time = []101 remain_time = []102 current_period = []103 tcb = TaskControlBlock(task_dictionary,104 name_list,105 period_time,106 central_processing_unit_time,107 remain_time,108 current_period)109110while tcb.CURRENT_TIME < close_time:111 tcb.scheduling(name_list,112 period_time,113 central_processing_unit_time,114 remain_time,115 current_period)EDF算法。
非抢占式优先级调度算法
非抢占式优先级调度算法非抢占式优先级调度算法是一种常见的进程调度算法。
在该算法中，每个进程都被赋予一个优先级，优先级越高的进程被优先调度执行，优先级较低的进程被暂时放置在队列中等待执行。
非抢占式优先级调度算法的主要思想是通过不断选择优先级最高的进程来满足进程的优先级需求，从而提高系统的响应速度和执行效率。
该算法旨在保证高优先级进程的快速响应，同时尽可能减少低优先级进程的等待时间。
非抢占式优先级调度算法的实现可以采用两个主要的数据结构：就绪队列和阻塞队列。
就绪队列存储所有已经就绪并且等待执行的进程，而阻塞队列存储正在等待某种资源而无法执行的进程。
当一个进程完成执行或者进入阻塞状态时，算法从就绪队列中选择下一个优先级最高的进程进行执行。
非抢占式优先级调度算法的优点是可以充分利用系统的资源，并根据进程的优先级进行合理的调度。
同时，该算法实现简单，适用于多种操作系统和硬件平台。
然而，该算法也存在一些缺点。
首先，进程的优先级需要提前设定，这可能会导致一些优先级设置不当的问题。
其次，当一个优先级较高的进程一直处于运行状态时，可能会导致低优先级进程长时间等待，出现饥饿现象。
为了解决非抢占式优先级调度算法的一些缺点，可以采用动态优先级调度算法。
在动态优先级调度算法中，调度器会根据进程的运行情况和系统的负载情况动态地调整进程的优先级。
当一个进程运行时间过长或者频繁发生阻塞时，其优先级会逐渐降低，以便给其他进程提供更多的执行机会。
反之，进程的优先级也会随着运行时长的增加而提高，以保证长时间未执行的进程得到合理调度。
总之，非抢占式优先级调度算法是一种常见的进程调度算法，用于根据进程的优先级进行合理的调度。
该算法简单易实现，适用于多种操作系统和硬件平台。
然而，该算法也存在一些缺点，可以通过引入动态优先级调度算法来解决。
非抢占式优先级算法例题
非抢占式优先级算法例题一、引言在计算机操作系统中，进程调度算法是核心部分，它负责合理地分配系统资源，使得各个进程能够高效地运行。
非抢占式优先级算法是进程调度算法中的一种，本文将详细介绍非抢占式优先级算法的基本概念、实例以及其在实际应用中的优缺点。
二、非抢占式优先级算法的基本概念1.定义非抢占式优先级算法是一种进程调度算法，其基本思想是：较高优先级的进程在等待较低优先级进程执行完毕后，才接过进程控制权执行。
2.特点非抢占式优先级算法具有以下特点：（1）较高优先级的进程不会被较低优先级的进程中断，必须等待较低优先级的进程执行完毕后才能执行。
（2）较低优先级的进程在执行过程中，如果有更高优先级的进程到来，也不会被抢占，必须等待当前进程执行完毕后，才能执行更高优先级的进程。
三、非抢占式优先级算法实例1.实例描述假设有一个进程P1，优先级为3；进程P2，优先级为2；进程P3，优先级为1。
现在三个进程同时启动，请根据非抢占式优先级算法进行调度。
2.算法实现根据非抢占式优先级算法，进程调度顺序应为：P1（优先级3）→ P2（优先级2）→ P3（优先级1）。
3.实例分析在这个例子中，进程P1优先级最高，首先执行。
当P1执行完毕后，进程P2优先级次之，接着执行。
同理，当P2执行完毕后，进程P3优先级最低，最后执行。
这种调度顺序保证了高优先级进程优先得到执行，符合非抢占式优先级算法的特点。
四、非抢占式优先级算法在实际应用中的优缺点1.优点非抢占式优先级算法的优点主要有：（1）保证了高优先级进程在低优先级进程之前得到执行，符合人们的认知习惯，易于理解和接受。
（2）在某些场景下，可以避免高优先级进程被低优先级进程频繁中断，提高系统性能。
2.缺点非抢占式优先级算法的缺点主要有：（1）低优先级进程可能会长时间占用系统资源，导致高优先级进程无法及时执行，影响系统响应速度。
（2）当高优先级进程数量较多时，低优先级进程可能长时间无法执行，导致系统资源浪费。
操作系统短作业优先进程调度算法
操作系统短作业优先进程调度算法操作系统中的进程调度算法是指决定哪个进程在一些时间点被执行的规则和策略。
短作业优先（SJF）是一种常见的进程调度算法，它根据进程的执行时间来安排执行顺序。
短作业优先算法的思想是，优先调度执行所需执行时间最短的进程，以最大程度地减少平均等待时间和周转时间。
这个算法适合用于处理那些执行时间相对较短的任务。
SJF算法可以按两种方式实现：非抢占和抢占。
非抢占式短作业优先调度算法是指一旦一个进程开始执行，就不能被中断或抢占，直到它完成或由于其中一种原因被阻塞。
抢占式短作业优先调度算法是指一个新到达的进程可以抢占正在执行的进程，如果新到达的进程的执行时间比当前正在执行的进程更短。
对于非抢占式短作业优先调度算法，可以使用一个队列来保存进程，并通过比较它们的执行时间来确定下一个要执行的进程。
具体实现如下：1.首先，将所有待处理的进程添加到队列中。
2.对队列中的进程按照执行时间进行排序，按照从短到长的顺序执行。
3.执行每个进程直到完成，然后将其从队列中移除。
4.重复步骤3，直到所有进程都执行完成。
对于抢占式短作业优先调度算法，可以使用一个就绪队列和一个运行队列来实现。
就绪队列用于保存已到达但尚未执行的进程，而运行队列是当前正在运行的进程。
具体实现如下：1.首先，将所有到达的进程添加到就绪队列中，按照到达时间进行排序。
2.从就绪队列中选择执行时间最短的进程，并将其添加到运行队列中。
3.执行运行队列中的进程直到完成或被抢占。
4.如果有新的进程到达，将其加入到就绪队列中。
5.如果当前运行的进程被抢占，将其放回就绪队列中，并选择一个新的执行时间最短的进程来执行。
6.重复步骤3至5，直到所有进程都完成。
非抢占式短作业优先调度算法可以保证最短平均等待时间和周转时间，但存在一个问题，即长作业会被无限期地推迟。
为了解决这个问题，可以使用抢占式短作业优先调度算法，但这也会导致较多的上下文切换。
因此，根据具体情况和需求，可以选择适合的算法来实现进程调度。
最早期限优先调度算法(EDF)的特点和实现
最早截止期优先调度算法（EDF）的特点及实现1 引言随着计算机的发展，多道程序处理的出现需要强大的调度算法来对多任务进行调度，以确定多任务环境下任务的执行顺序以及占有CPU时间。
相对于静态、不可抢占的调度方法，EDF的出现使之凭借灵活性高、CPU占有率高很快成为最优的单处理器调度算法。
2 任务调度的基本概念在计算机发展的初期，需要使用计算机时，通常要集中在计算机所在的地方，人为的以作业的方式把工作内容一件一件的交给计算机处理，也就不存在调度的概念。
随后，出现了计算机的批处理方式，计算机把作业按照先来先服务的方式进行处理，体现了一种非常简单的调度概念。
随着多道程序处理方式的出现，调度逐渐变得重要和复杂起来。
在多任务的实时操作系统中，调度是一个非常重要的功能，用来确定多任务环境下任务执行的顺序和获得CPU资源后能够执行的时间长度。
操作系统通过一个调度程序看来实现调度功能，调度程序以函数的形式存在，用来实现操作系统的调度算法。
调度程序是影响系统性能（如吞吐率、延迟时间等）的重要部分。
在设计调度程序时，通常要综合考虑如下因素：CPU的使用率、输入、输出设备的吞吐率、响应时间、公平性和截止时间。
这些因素之间有一定的冲突性，在设计调度程序时需要优先考虑最重要的需求，然后再各种因素之间进行折中处理。
3 调度方法的分类对于大量的实时调度方法来说，主要存在以下几种划分方法：1、离线（off-line）和在线（on-line）调度根据获得调度信息的时机，调度算法可以分为离线调度和在线调度两类。
对于离线调度算法，运行过程中使用的调度信息在系统运行之前就确定了，如时间驱动的调度。
离线调度算法具有确定性，但缺乏灵活性，适用于特征能够预先确定，且不容易发生变化的应用。
在线调度算法的调度信息则在系统运行过程中动态获得，如优先级驱动的调度（如EDF,RMS等）。
在线调度算法在形成最佳调度决策上具有较大的灵活性。
2、抢占（preemptive）和非抢占（non-preemptive）调度根据任务在运行过程中能否被打断的处理情况。
最早期限优先调度算法(EDF)实验报告
实验报告实验名称：最早期限优先调度算法（EDF)实验一、实验目的1）了解实时调度，了解最早截止期优先算法（EDF算法）；2）使用C语言实现最早截止期优先算法(EDF算法)；3）计算多个任务的调度顺序。
二、实验原理最早截止期优先算法(EDF），也称为最早死限调度算法（DDS），是一种采用动态调度的优先级调度算法,任务的优先级根据任务的截止时间来确定。
任务的截止时间越近，任务的优先级越高；任务的截止时间越远,任务额优先级越低.当有新的任务处于就绪状态时，任务的优先级就有可能需要进行调整。
EDF算法的测试如果所有的任务都是周期性的,并且对应的时间限等于它们的周期，对任务集的调度性的测试是非常简单的：如果任务集的总利用率不大于1,那么任务集就可以由EDF算法在一个单处理器上进行合理的调度.对于那些任务的时间限并不全等于其周期的情况，没有简答的调度性测试。
在这样的情况下，需要使用EDF算法生成一个时间表，来判断是不是在一个给定的时间区间内所有的时间限都被满足。
在这种情况下EDF的一个可调度性测试如下:定义,以及（这里的“lcm”表示最小公倍数）.定义是任务集T中所有满足其时间限的绝对值小鱼t的任务执行时间之和。
一个由n个任务构成的集合不是可行的EDF的充分必要条件是：或存在某个使得（其中n为任务集中任务的数量；为任务的执行时间；为周期任务的周期；为任务的相对时间限；为在绝对时间不迟于t的任务集合T中,所有重复的任务执行时间和。
）三、实验仪器硬件:PC机；软件：Windows7，Visual Studio 2010集成开发环境四、实验步骤1）理解EDF调度算法的原理并通过实例用EDF算法判断多任务的调度顺序。
2）新建EDF。
h 头文件，在其中定义变量，结构体，函数.3）新建input。
c文件，用input函数从键盘获取多个任务的名称、执行时间、周期和释放时间，将任务分成一个个时间片存在数组中,并输出数组和各时间片属性。
最短作业优先（抢占和非抢占）
最短作业优先（抢占和非抢占）一、流程图解析：在最开始，我们先创建若干进程，选择自动运行，则在运行完后，按顺序显示运行的结果。
同理，选择手动运行，那么就是最先选择最短的作业开始运行，其实当前进程并非一定在实际运行（改变自己的状态），只是一个虚拟的运行（虚拟最短作业优先运行算法），这时我们可以做其他的事情，在做事之前，先运行虚拟算法，依照最短作业优先去改变相关进程的状态（进程可能就没有实际运行过，被虚拟算法改变了状态（就绪、等待、终止）），在做完相关事情之后，再运行虚拟算法，确定是否要发生最短作业的优先抢占。
根据以上的运行结构，我们可以在这结构的基础上，人为地设置进程状态就是改变进程状态，这时就可以发生最短作业调度的抢占和非抢占式。
我们可以进入查看进程状态，看看运行的状况，也可以进入修改进程状态，修改相关进程状态让其发生最短作业的抢占，或者进入创建进程，创建一个新的进程，这是也有可能实现最短作业优先的抢占。
二、虚拟运行算法：从进程的结构分析，进程里面有状态，到达时间（取系统时间），结束时间（取系统时间），需要运行时间，已运行时间等，我们知道第一个最短作业运行的到达时间（开始运行的时间）就是创建的时间。
在一个进程运行终止时，要设好终止的时间、改变状态等属性，这时进行进程间信息交换，终止进程的时间交给下一个要运行的进程的到达时间，这样不断下去就可以运行到最后一个进程，当发生抢占调度时，也是以上的情况运行。
先在抢占之前，就运行虚拟算法，改变相关的进程状态，发生引起抢占的事的时候就可以利用抢占来进行进程的切换。
这样就能让C PU在有工作做时就不能空闲。
直到把所有在就绪队列的进程运行完，这是CPU可以休息了，如果在CPU休息时有进程从等待进入就绪，那么CPU就要继续开工。
时限调度算法
7-18-16-时限调度算法时限调度算法（Deadline Scheduling Algorithm）是一种用于管理任务或作业执行顺序的算法，其中每个任务都有一个特定的截止时间（deadline）和执行时间（processing time）。
这些任务需要在给定的截止时间之前完成，否则可能会导致问题或不符合约定。
时限调度算法的目标是在满足截止时间限制的前提下，尽量提高任务的执行效率。
以下是几种常见的时限调度算法：1. 最早截止时间优先（Earliest Deadline First, EDF）：• EDF算法的思想是在每个时刻，选择截止时间最早的任务来执行。
•这意味着优先执行那些紧急的任务，以确保它们在截止时间之前完成。
• EDF算法通常用于实时系统，以确保关键任务按时执行。
2. 最早截止时间优先的变种（EDF-VD）：•这是EDF算法的一种变种，它考虑了任务的惩罚因子，以决定哪个任务应该优先执行。
•任务的惩罚因子反映了任务没有按时完成时可能产生的损失或惩罚。
• EDF-VD算法尝试最小化总惩罚。
3. 最大松弛度优先（Laxity Scheduling）：•在这种算法中，每个任务都有一个松弛度（laxity），它表示任务可以延迟多少时间而不会违反截止时间。
•选择具有最大松弛度的任务来执行，以确保截止时间内完成，并允许尽可能多的任务延迟。
4. 周期性调度算法（Periodic Scheduling）：•这类算法通常用于实时系统，其中任务具有周期性的执行要求。
•常见的周期性调度算法包括周期性率单调（Rate Monotonic Scheduling）和周期性优先级调度（Fixed Priority Scheduling）。
这些算法的选择取决于具体应用场景和任务要求。
时限调度算法通常用于嵌入式系统、实时操作系统和其他需要满足任务截止时间的应用程序中。
在选择算法时，需要考虑任务的特性、截止时间、执行时间和系统资源，以便找到最合适的调度策略。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
第２ ９卷 第 ２期 ２１ ０ ２年 ２月
计 算 机 应 用 研 究
Ａｐ ｌｃ ｔ ｎ Ｒｅ ｅ ｒ ｈ ｏ ｏ ｕ ｅ ｓ ｐ ｉ ａｉ ｓ ａ ｃ ｆＣ ｍｐ ｔ ｒ ｏ
Ｖｏ ． ９ Ｎｏ ２ １２ ． Ｆ ｂ ０１ ｅ ．２ ２
非 抢 占式 Ｅ 法 下周 期 性 任 务 的 Ｆ算 Ｄ 最小 相对 截 止 期 计 算 术
ＥＤ ｉ ｐ ｏ ｏ ｅ ｎ ａ ｇ ｒ ｈ ｆｒ ｃ ｌ ｕ ａｉ ｇ ｔｅ ｍｉ ｉ ｍ ｏ — ｒ ｅ ｔ ｅＥＤＦ ｆ ａ ｉ ｌ ｅ ｄ ｉｅ ｏ ｅ ｌｔ ｓａ ｅ ．Ａｎ Ｆ， ｒ ｐ ｓ ｄ ａ ｌ ｏ ｔ ｍ ａ ｃ ｌｔ ｈ ｎ ｍｕ ｎ ｎ ｐ ｅ ｍｐ ｉ ｔ ｉ ｏ ｎ ｖ — ｓｂｅ ｄ ａ ｌ ｆｒ ａ—ｉ ｍｅ ｓ ｇ ｓ ｅ ｎ ｍｅ ｄ ｓｍｕ ａｉ ｎ ｒ ｓ ｈ ｈ ｗ ｔ ａ ｈ ｌｏ ｔ ｍ ｃ ｎ ｏ ｅ ａ ｅ ｅｆｃ ｉｅｙ ｉ ｌ ｔ ｅ ｕ ｓｓ ｏ ｔ ｅ ａｇ ｒ ｈ ａ ｐ ｒ ｔ ｆｅ ｔ ｌ ． ｏ ｈ ｔ ｉ ｖ
Байду номын сангаас
于 当任 务 为基 于非抢 占式 Ｅ Ｆ 度算 法 的场合 ， 实时通信 领 域 。在 分析 了非抢 占式 Ｅ Ｆ 度 算 法 的 可调 度 Ｄ 调 如 Ｄ 调
性 判 定条件 基础 上 ， 出 了基 于非 抢 占式 Ｅ Ｆ调 度 算 法 下周 期 性任 务 最小 相 对截 止期 的计 算 算 法。 算 法通 过 提 Ｄ 逐 渐增 加任 务 的相对 截止期 直 到使任 务 集 变为可调 度 的方式 ， 实现 某个任 务相 对截止 期 的最 小化 。仿 真 实验 表 明该 算法具 有较好 的计 算复杂度 。 关 键词 ：实时 系统 ；时延 抖动 ；非抢 占式 Ｅ Ｆ算 法 周期 性任 务 ；相 对截 止期 Ｄ
Ａｂ ｔ ａ ｔ Ｃ ｒｅ ｔ ｅ ｄ ｉ ｅ ｍｉ ｉ ｚ ｔ ｎ ｍｅｈ ｄ ｈ ｔ ｃ ｍｐ ｔ ｈ ｈ ｒ ｓ ｄ ａ ｌ ｅ ｏ ｅ ｉｄ ｃ ｔ ｓ ｒ ｉ ｔ ｄ ｂ ｃ ｕ ｅ ｓｒ ｃ ： ｕ ｒ ｎ ａ ｌ ｎ ｍｉａｉ ｔ ｏ ｓ ｔ ａ ｏ ｕ ｅ ｔ ｅ ｓ ｏ ｔ ｔ ｅ ｄ ｉ ｆａ ｐ ｒ ｉ ａ ｋ ａ ｅ ｌ ｅ ｅ ａ ｓ ｄ ｎ ｏ ｅ ｎ ｏ ｍｉ
中图分 类号 ：Ｔ ３ ３ Ｐ９ 文献标 志码 ：Ａ 文章 编号 ：１ ０ —６ ５ ２ １ ） ２ ０ ２ — ３ ０ １３９ （０２ ０ —７２０
ｄ ｉ１ ．９ ９ ｊｉ ｎ １０ —６ ５ ２ １ ．２ ０ ６ ｏ：０ ３ ６ ／．ｓ ． ０ １３ ９ ．０ ２ ０ ．８ ｓ
Ｍｉｉ ｍ ｅａｉｅｄ ａ ｌ ｅｃ ｌｕａｉｎ ｆｒｐ ｒｏ ｉ ｅ ｌｔ ｎｍｕ ｒｌｔ ｅ ｄｉ ａｃ ｌｔ ｏ ｅｉｄｃｒａ— ｍｅ ｖ Ｈ ｏ ｉ
檀 明 ， 魏 臻 韩江洪 ，
（． １ 合肥 学院 网络 与智能信 息处理 重点 实验 室 ， 合肥 ２ ００ ；２ 合肥 工业 大学 计算机 与信息 学院 ， ３６ １ ． 合肥 ２ ００ ） ３ ０ ９
摘
要 ：现 有 的求解 周期性 任务 最 小相 对截 止期 的方 法 均假 定任 务 集是 采取 抢 占式 Ｅ Ｆ调度 算 法 ， 不适 用 Ｄ 并
ｔ ｓ ｓ ｓ ｈ ｄ ｌ ｄ ｂ ｏ ・ ｒ ｅ ｔｖ ａ ｋ ｃ ｅ ｕ ｅ ｙ ｎ ｎ－ ｅ ｍｐ ｉ ｅ ＥＤＦ ａ ｇ ｒｔ ｍ ｐ ｌ ｏ ｉｈ
Ｔ ｎ ＡＮ Ｍｉｇ一，Ｗ Ｅ ｈ ｎ ，ＨＡＮ Ｊａ ｇｈ ｎ 。 ＩＺ ｅ ｉｎ —ｏ ｇ
（ ． ｅ ａ ｏａｏｙｏ ｅ ｏ １ ＫｙＬ ｂｒｔｒ ｆＮ ｔ ｒ Ｉｔｌｇｎ Ｉ ｏｍａｉ ｒ ｅｓ ｇ， ｅ ｉ ｎｖｒｔ， ｆｉ ３ ６ １ Ｃ ｉａ ２ ｃｏｌ Ｃ ｍ ｕｅ ＆ ｌ ｏｍ — ｗ ｋ＆ ｎｅｌ ｅｔｎ ｒ ｔ ｎＰｏ ｓ ｎ Ｈｆ ｉ ｓｙ Ｈｅ ０ ０ ， ｈｎ ； ．Ｓｈｏ ｏ ｏ ｐ ｔ ｉ ｆ ｏ ｃ ｉ ｅＵ ｅｉ ｅ２ ｆ ｒ ￣ ｒ ａ ｆ ｔｎ， ｅ ｉＵ ｉ ｒｔ ｏ Ｔｃｎｌ ｙ ｅ ｉ ３ ０ ９ ｈｎ ） ｉ Ｈｆ ｎｖ ｓｙｆ ｅｈｏｏ ，Ｈｆ ０ ０ ，Ｃ ｉａ ｏ ｅ ｅ ｉ ｇ ｅ２
Ｋｅ ｏ ｄ ：ｒａ—ｍｅｓｓ ｍ； ｕｐ ｔ ｉｅ ；ｎ ｎｐ ｅ ｍ ｔ ｅＥ Ｆ ａ ｏｉ ｍ； ｅｉ ｉ ｔ ｋ ｒｌｔ ｅｄ ａ ｌ ｅ ｙｗ ｒ ｓ ｅ ｌ ｉ ｙｔ ｔ ｅ ｏ ｔｕ ｔ ｒ ｏ —ｒｅ ｐｉ Ｄ ｌ ｒ ｈ ｐ ｒ ｄｃ ａ ； ｅａ ｖ ｅ ｄｉ ｊｔ ｖ ｇ ｔ ｏ ｓ ｉ ｎ