精华内容
下载资源
问答
  • 操作系统调度程序模拟器 安装 为了能够使用OS3,您只需要一个浏览器。 现在可以执行index.html文件了。 要修改的东西,它需要安装node , watchify , browserify , uglifyjs和npm git clone git@github....
  • OS中的调度

    2019-11-13 20:51:57
    文章目录OS中的算法CPU调度三种调度方式高级调度中级调度低级调度调度的时机进程调度有关进程调度的基本概念算法FCFS先到先来服务SJF短作业优先优先级调度算法HRRN高响应比优先RR(Round-Robin)时间片轮转多级反馈...

    OS中的算法

    讨论顺序按CPU<->内存<->磁盘的顺序展开,

    CPU<->内存:主要对象是作业和进程,发生调度的场景是CPU和内存,偶尔涉及到外存。

    内存<->磁盘:主要对象是数据,发生调度的场景是内存和磁盘

    CPU调度

    三种调度方式

    面向作业,进程,CPU和内存分为三种

    高级调度

    又称作业调度,是将作业从外存中调入内存,将作业处理完后再把作业从内存调至外存,作业的调入调出只会发生一次

    中级调度

    又称内存调度,面向进程,当内存空间不足时,OS会把暂时不能运行的进程调至外存等待,此时的进程称为挂起态,注意这个时候进程映像被调至外存,但是进程的PCB仍然存在于内存中

    低级调度

    又称进程调度,是在内存中的调度,按照进程调度算法从就绪队列中选择一个进程将CPU的资源分配给它。

    三种调度发生频率调度对象涉及位置
    作业调度作业内存——外存
    内存调度进程内存——外存
    进程调度进程内存

    调度的时机

    不能进行调度的情况:

    • 处理中断
    • 进程在OS内核程序临界区
    • 其它需要完全屏蔽中断的原子操作

    可以进行进程调度的情况:

    • 进程时间片用完
    • 进程发出中断指令切换到阻塞态
    • 进程无法继续执行时

    补充说明:

    临界资源是指在同一时间只能有一个进程访问的资源,比如说输入机,打印机等等,临界区是访问临界资源的代码段,进程准备进入临界区之前需要检查是否有其它进程在使用这个资源,如果有则阻塞自己,如果没有则进入给临界资源加锁并且进入临界区,退出临界区时进程会解锁以便其它进程访问。

    进程调度

    前面提到,CPU的进程调度会根据一定算法从就绪队列中选择一个进程来执行,那么这个算法就涉及到进程调度

    有关进程调度的基本概念

    • 长作业,短作业,运行时间长的称为长作业,运行时间短的成为短作业。一般CPU繁忙型进程由于需要使用长时间的CPU资源,所以它是长作业,而IO繁忙型进程只需要得到CPU然后发出I/O请求就可以做别的事了,索引它是短作业。、从性能上来说,CPU应该优先满足短作业,再满足长作业。

    • 优先级

      优先级别高的进程会更先使用CPU,进程可以按照优先级分为

      系统进程>非系统进程

      交互型>非交互型

      I/O型>非I/O型

    • 抢占式非抢占式,当一个进程使用CPU资源的时候,其它进程只能等待它使用完成才轮到自己使用,这种方式就要非抢占式,与之相对应的是抢占式,当其它进程需要使用CPU的时候OS可以剥夺当前正在运行的进程的CPU资源提供给新的进程使用。

    • 衡量调度算法的指标

      • 周转时间=完成时间-到达时间
      • 平均周转时间=总的周转时间/作业数
      • 带权周转时间=周转时间/实际运行时间
      • 平均带权周转时间=总的带权周转时间/作业数
      • 等待时间,指进程等待处理机资源的时间
      • 响应时间,指用户提交请求到系统首次产生响应所用的时间
      • CPU利用率=CPU运行时间/总时间
      • 系统吞吐量,指单位时间内CPU完成作业的数量

    算法

    FCFS先到先来服务

    按照进程到达时间先后顺序执行,先到达的进程先服务

    SJF短作业优先

    顾名思义,运行时间短的进程优先执行

    优先级调度算法

    其中可以分为抢占式和非抢占式,按照一定规则使得优先级别高的进程先运行,这种调度算法会饥饿

    HRRN高响应比优先

    比较优秀的一个算法,兼顾了短作业优先并且让长作业不会饥饿

    响应比计算方法是:

    响 应 比 = 等 待 时 间 + 要 求 服 务 时 间 要 求 服 务 时 间 响应比=\frac{等待时间+要求服务时间}{要求服务时间} =+

    RR(Round-Robin)时间片轮转

    不会饥饿,适用于多用户系统

    时间片过长会退化成FCFS,时间片过短,性能会下降

    多级反馈队列

    同样是解决了短作业,长作业算法的缺点的算法,进程不会饥饿

    总结

    算法思想优点缺点是否饥饿适用于特点
    FCFS按序服务不会饥饿对短作业(I/O型)不好CPU型作业频繁有利于长作业,不利于短作业;算法简单,效率低
    SJF所花时间短的先服务会饥饿对长作业(CPU型)不好I/O型作业频繁对长作业不利。平均等待时间和平均周转时间最少(不考虑饥饿的话性能最优)
    优先级优先级别高的先服务紧急任务可以优先使用CPU饥饿任务有紧急性,需要较快响应的系统,终端型作业和短作业衍生算法多,有抢占式和非抢占式两种,同时可以动态调整优先级避免产生饥饿
    HRRN响应比高的进程先服务兼顾了长作业和短作业无明显缺点短作业响应比天然高,长作业由于等待时间长响应比也会升高从而不会饥饿
    RR按照时间片来分配进程资源分时系统最适合的算法无明显缺点多用户系统,分时系统时间片的选取很关键,时间片长则退化成FCFS,时间片短则频繁切换进程开销过大
    多级反馈队列优先级队列+时间片轮转终端型:短作业优先。短作业:周转时间短。长作业不会饥饿无明显缺点可以衍生出很多算法

    内存调度

    内存中引入非连续分配时,由于发生缺页的时候要根据一定算法选择换入,换出的页,因此有了专门的调度算法,在讲算法之前,先说一下操作系统划分内存的分配方式,重点关注的是调页算法

    操作系统内存的分配方式有两种,一种是连续分配,另一种是非连续分配

    连续分配

    连续分配是指一个进程的数据存放位置必须是连续的

    • 单一连续分配

      整个内存只分配给一个进程,用于早期的操作系统。注意只有这种分配方式是给一道进程的,其它都是给多道进程的

    • 固定分区分配

      将内存划分为固定分区,每个进程装入适合的分区中

      因为一开始就划分好了分区,所以称为固定分区

      分区方式有两种:

      • 分区大小不变
      • 分区大小可变
    • 动态分区分配

      一开始并不划分分区,而是根据进程运行时动态的调整分区大小,当一个进程装入时根据算法装入合适的位置

      分区分配算法主要有这几种

      • BF(best fit)最佳适应

        算法选择一个最合适的内存空间装入,此算法需要维护一个存储内存空间大小的链表,从小到大排序,因此这个算法需要额外的时间和空间去维护链表

      • WF(worst fit)最坏适应

        总是选择一个最大的内存空间装入,此算法同样要维护一个从大到小排序的链表,需要额外的时间和空间

      • FF(first fit)首次适应

        选择一个第一次能满足进程所需空间大小的内存块装入。由于装入发生在低地址段的频率较高,所以低地址处会有许多碎片

      • NF(next fit)邻近适应

        FF的改进版,从上一次比较的位置开始寻找内存块,而不是从头开始寻找内存块。NF会造成大的内存空间分裂成小碎片。

        以上四种算法FF性能最好,BF和WF性能都很差

        算法之间的比较

        名词性能额外空间特点
        BF有序链表留下很多小碎片(外部碎片)
        WF有序链表大块的内存被分割了
        FF最优低地址处留下很多碎片,增加了查找时间
        NF还可以把大空间分割了

        大块的空间被分割是很可惜的事情,因为可能找不到空间装入某些大进程

        很多的小碎片也很麻烦

    上述三种分区方法的比较(注意这里始终是连续分配方式下的不同分区方法)

    名称碎片类型支持进程特点
    单一连续分配一个唯一采用覆盖和交换的分配方式,用于早期的操作系统
    固定分区分配多个不能实现多进程共享存储区,内存利用率低
    动态分区分配多个会产生很多小的碎片

    非连续分配

    特别重要的一个知识点

    • 页式

      将内存分成固定大小的分区,每一个分区称之为页框/页帧/内存块/物理块(内存块的说法贴切)

      需要一个索引表来指向分区,索引表的内容就是块号,索引表称为页表,索引表中的项称为页表项

      用户程序也按页分,这里的每一页对应内存中的一个内存块

    • 段式

      将内存分为长度不等的段,此时索引表的内容是(段长,起始地址)

      段式比页式更方便的实现数据和信息共享

    • 段页式

      先分段,再分页

    名词碎片类型索引表内容特点
    页式内部块号最常用
    段式外部段长,内存中起始地址更方便的实现数据和信息共享
    段页式内部段长,页表中起始地址;块号结合两者优点

    缺页置换算法

    OPT最佳置换算法

    思想:每次发生缺页时,从当前时刻向后看,找到当前内存中最后使用的页,然后置换

    例如

    块号\访问页号23141432
    122242
    23333
    3111
    是否缺页

    9次访问,共缺页5次,最后一次缺页随机选择一个页换出即可

    请注意:OPT算法由于需要缺页之后的访问顺序,而os中无法知道进程执行过程中页的访问顺序,所以OPT算法只是理论上的算法,无法实现

    FIFO先进先出置换算法

    思想:维护一个页号队列,每次发生缺页时,置换队首页号

    FIFO很直观,但是会产生Belady异常,即:增加物理块反而会增加缺页次数,这是由于FIFO要使用队列,而基于堆栈类的算法(LRU)不会产生Belady异常

    LRU最近最久未使用置换算法

    思想:每次发生缺页时,从当前时刻往前看,找到当前内存中最久未使用的页,然后置换

    为了模仿OPT而产生的算法,性能比较好,但是需要寄存器和栈的硬件支持,因此开销比较大

    CLOCK时钟算法,又称为NRU最近未用算法

    思想:增加修改位,按照顺/逆时间遍历所有的页号,将符合要求的页换出,下一次缺页时从上次换入的页开始遍历

    流程

    第一轮扫描,选择未修改的页置换,此时将扫描过的页的修改位置为0

    重复第一轮扫描,总能找到一页置换

    CLOCK的改进型

    思想:增加更多的标志位,(访问位,修改位)

    假设(1,1)表示访问,且有修改,(1,0)表示访问但未修改

    因为修改过的页要花更多的时间写回磁盘,我们优先选择未修改过的页

    又因为根据局部性原理,访问过的页很有可能不久再被访问,所以我们优先换出未访问的页。

    流程

    第一轮扫描,选择(0,0)的页置换

    第二轮扫描,选择**(0,1)**的页置换,也就是未被访问但是被修改过的页。此轮将扫描过的修改位改为1

    重复上述两轮扫描,总是能找到一页并置换

    此算法换页的淘汰顺序是:(0,0) > (0,1) > (1,0) > (1,1)

    请注意实际上不存在(0,1)的页,也就是不存在未被访问但是修改过的页,这是算法执行过程中修改标志位导致的

    磁盘调度

    为什么要磁盘调度?

    因为CPU要读入数据,数据不在内存中,OS就从磁盘中读取数据到内存中,磁盘中如何调度,按照什么顺序调度,就涉及到下面的算法

    基本概念

    磁盘的组成:磁头,磁臂,盘片

    解释:磁头读取数据,磁臂负责移动磁头,盘片存储数据

    盘片的组成:盘面,磁道,扇区(盘块)

    一个盘片有上下两个盘面组成,一个盘面有多条磁道,磁道越多磁盘可以存储的数据就越多,一个磁道可以等分为多个扇区

    所有盘片的同一磁道组成柱面

    磁盘访问时按照(柱面,盘面,扇区)的顺序访问

    因为移动磁臂的开销很大,所以优先确保这个柱面上所有需要读入的磁道都读取入完了才 移动磁臂。然后保证同一个盘面没有要读入的内容了,再切换扇区

    算法

    FCFS,先来先服务算法

    思想:按照请求序列,先来的先读

    SSTF 最短寻找时间优先

    思想:总是优先满足离磁头最近的请求

    特点:会饥饿

    SCAN扫描算法,又称电梯调度算法

    规定磁头移动方向,只有磁头移动到一端后才反向移动

    不会饥饿,但是由于靠近一端的请求序列会在短时间内扫过两次所以对请求序列不公平

    C-SCAN,循环扫描

    规定磁头移动方向,只有磁头移动到一端后,才从另一端开始移动

    LOOK,C-LOOK

    LOOK对应SCAN

    C-LOOK对应C-SCAN

    带有LOOK标识的,表示以上两个算法的磁头并不是严格的执行到另一端再返回,而是遇到该方向最后一个请求就开始反转移动方向。

    SSTF 最短寻找时间优先

    思想:总是优先满足离磁头最近的请求

    特点:会饥饿

    SCAN扫描算法,又称电梯调度算法

    规定磁头移动方向,只有磁头移动到一端后才反向移动

    不会饥饿,但是由于靠近一端的请求序列会在短时间内扫过两次所以对请求序列不公平

    C-SCAN,循环扫描

    规定磁头移动方向,只有磁头移动到一端后,才从另一端开始移动

    LOOK,C-LOOK

    LOOK对应SCAN

    C-LOOK对应C-SCAN

    带有LOOK标识的,表示以上两个算法的磁头并不是严格的执行到另一端再返回,而是遇到该方向最后一个请求就开始反转移动方向。

    展开全文
  • OS- -调度(二)

    2020-08-02 00:34:52
    交互式系统中的调度轮询调度(时间片法)优先级调度多级队列最短进程优先保证调度彩票调度公平分享调度4.实时系统中的调度5.调度策略和机制6.线程调度 一、调度 3.交互式系统中的调度 交互式系统中在个人计算机、...

    OS- -调度(二)

    一、调度

    3.交互式系统中的调度

    交互式系统中在个人计算机、服务器和其他系统中都是很常用的,所以有必要来探讨一下交互式调度

    轮询调度(时间片法)

    • 一种最古老、最简单、最公平并且最广泛使用的算法就是轮询算法(round-robin)

    • 每个进程都会被 分配一个时间段,称为时间片(quantum),在这个时间片内允许进程运行。

    • 如果时间片结束时进程还 在运行的话,则抢占一个CPU并将其分配给另一个进程。

    • 如果进程在时间片结束前阻塞或结束,则 CPU立即进行切换。

    • 轮询算法比较容易实现。调度程序所做的就是维护一个可运行进程的列表,就像 下图中的a,当一个进程用完时间片后就被移到队列的末尾,就像下图的b。
      在这里插入图片描述

    • 时间片轮询调度中唯一有意思的一点就是时间片的长度

    • 从一个进程切换到另一个进程需要一定的时间 进行管理处理,包括保存寄存器的值和内存映射、更新不同的表格和列表、清除和重新调入内存高速缓 存等。这种切换称作 进程间切换(process switch)和 上下文切换(context switch)。

    • 如果进程 间的切换时间需要1ms,其中包括内存映射、清除和重新调入高速缓存等,再假设时间片设为4 ms, 那么CPU在做完4 ms有用的工作之后,CPU将花费1 ms来进行进程间的切换。

    • 因此,CPU的时间 片会浪费20%的时间在管理开销上。耗费巨大。

    • 为了提高CPU的效率,我们把时间片设置为100 ms。现在时间的浪费只有1%。

    • 但是考虑会发现下面 的情况,如果在一个非常短的时间内到达50个请求,并且对CPU有不同的需求,此时会发生什么?

    • 50个进程都被放在可运行进程列表中。如果CPU是空闲的,第一个进程会立即开始执行,第二个直 到100 ms以后才会启动,以此类推。

    • 不幸的是最后一个进程需要等待5秒才能获得执行机会。大部分 用户都会觉得对于一个简短的指令运行5秒中是很慢的。如果队列末尾的某些请求只需要几号秒钟的运 行时间的话,这种设计就非常糟糕了。

    • 另外一个因素是如果时间片设置长度要大于CPU使用长度,那么抢占就不会经常发生。相反,在时间 片用完之前,大多数进程都已经阻塞了,那么就会引起进程间的切换。消除抢占可提高性能,因为进程 切换仅在逻辑上必要时才发生,即流程阻塞且无法继续时才发生

    • 结论可以表述如下:将上下文切换时间设置得太短会导致过多的进程切换并降低CPU效率,但设置时 间太长会导致一个短请求很长时间得不到响应。最好的切换时间是在20 -50毫秒之间设置

    优先级调度

    • 轮询调度假设了所有的进程是同等重要的。但事实情况可能不是这样。

    例如,在一所大学中的等级制 度,首先是院长,然后是教授、秘书、后勤人员,最后是学生。

    这种将外部情况考虑在内就实现了优先 级调度(priority scheduling)
    在这里插入图片描述

    例如你的家庭地位:孩子 > 女朋友 > 狗🐶 >你自己😊🐯

    • 它的基本思想很明确,每个进程都被赋予一个优先级,优先级高的进程优先运行
    • 但是也不意味着高优先级的进程能够永远一直运行下去,调度程序会在每个时钟中断期间降低当前运行 进程的优先级
    • 如果此操作导致其优先级降低到下一个最高进程的优先级以下,则会发生进程切换。或 者,可以为每个进程分配允许运行的最大时间间隔。当时间间隔用完后,下一个高优先级的进程会得到 运行的机会
    • 可以静态或者动态的为进程分配优先级
    • 在一台军用计算机上,可以把将军所启动的进程设为优先级100,上校为90,少校为80,上尉为70,中尉为60,以此类推。
    • UNIX中有一条命令为nice ,它允许用户为了照顾他人而自愿降低自己进程的优先级,但是一般没人用。
    • 优先级也可以由系统动态分配,用于实现某种目的

    • 例如,有些进程为I/O密集型,其多数时间用来等 待I/O结束。当这样的进程需要CPU时,应立即分配CPU,用来启动下一个I/O请求,这样就可以在 另一个进程进行计算的同时执行I/O操作。

    • 这类I/O密集型进程长时间的等待CPU只会造成它长时间 占用内存。使I/O密集型进程获得较好的服务的一种简单算法是,将其优先级设为1/f , f为该进程 在上一时间片中所占的部分。

    • 一个在50 ms的时间片中只使用1 ms的进程将获得优先级50 ,而在阻 塞之前用掉25 ms的进程将具有优先级2,而使用掉全部时间片的进程将得到优先级1。

    • 可以很方便的将一组进程按优先级分成若干类,并且在各个类之间采用优先级调度,而在各类进程的内 部采用轮转调度。

    下面展示了一个四个优先级类的系统
    在这里插入图片描述

    • 它的调度算法主要描述如下:上面存在优先级为4类的可运行进程,首先会按照轮转法为每个进程运行 一个时间片,此时不理会较低优先级的进程。
    • 若第4类进程为空,则按照轮询的方式运行第三类进程。
    • 若第4类和第3类进程都为空,则按照轮转法运行第2类进程。
    • 如果不对优先级进行调整,则低优先 级的进程很容易产生饥饿现象。

    多级队列

    • 最早使用优先级调度的系统是CTSS(Compatible Timesharing System)

    • CTSS是一种兼容分时 系统,它有一个问题就是进程切换太慢,其原因是旧M 7094内存只能放进一个进程。
      在这里插入图片描述

    • CTSS在每次切换前都需要将当前进程换出到磁盘,并从磁盘上读入一个新进程

    • CTSS的设计者很快 就认识到,为CPU密集型进程设置较长的时间片比频繁地分给他们很短的时间要更有效(减少交换次 数)。

    • 另一方面,如前所述,长时间片的进程又会影响到响应时间,解决办法是设置优先级类。

    • 属于最 高优先级的进程运行一个时间片,次高优先级进程运行2个时间片,再下面一级运行4个时间片

    • 以 此类推。当一个进程用完分配的时间片后,它被移到下一类。

    最短进程优先

    • 对于批处理系统而言,由于最短作业优先常常伴随着最短响应时间,所以如果能够把它用于交互式进程,那将是非常好的。在某种程度上,的确可以做到这一点。

    • 交互式进程通常遵循下列模式:等待命 令、执行命令、等待命令、执行命令。。。

    • 如果我们把每个命令的执行都看作一个分离的作业,那么我 们可以通过首先运行最短的作业来使响应时间最短。

    • 这里唯一的问题是如何从当前可运行进程中找出最 短的那一个进程

    • 一种方式是根据进程过去的行为进行推测,并执行估计运行时间最短的那一个。

    • 假设每个终端上每条命 令的预估运行时间为T0 ,现在假设测量到其下一次运行时间为T1 ,可以用两个值的加权来改进估 计时间,即aT0+ (1- 1)T1

    • 通过选择a的值,可以决定是尽快忘掉老的运行时间,还是在一段长 时间内始终记住它们。

    当a = 1/2时,可以得到下面这个序列
    在这里插入图片描述

    • 可以看到,在三轮过后,T0在新的估计值中所占比重下降至1/8。
    • 有时把这种通过当前测量值和先前估计值进行加权平均从而得到下一个估计值的技术称作老化 (aging)。这种方法会使用很多预测值基于当前值的情况。

    保证调度

    • 一种完全不同的调度方法是对用户做出明确的性能保证

    • 一种实际而且容易实现的保证是:若用户工作 时有n个用户登录,则每个用户将获得CPU处理能力的1/n

    • 类似地,在一个有n个进程运行的单用 户系统中,若所有的进程都等价,则每个进程将获得1/n的CPU时间。

    彩票调度

    • 对用户进行承诺并在随后兑现承诺是一件好事,不过很难实现。但是存在着一种简单的方式,有一种既可以给出预测结果而又有一种比较简单的实现方式的算法,就是彩票调度(lottery scheduling)算 法
    • 其基本思想是为进程提供各种系统资源(例如CPU时间)的彩票。当做出一个调度决策的时候,就随 机抽出一张彩票,拥有彩票的进程将获得该资源。在应用到CPU调度时,系统可以每秒持有50次抽 奖,每个中奖者将获得比如20毫秒的CPU时间作为奖励。
    • George Orwell关于所有的进程是平等的,但是某些进程能够更平等一些。一些重要的进程可以给 它们额外的彩票,以便增加他们赢得的机会。
    • 如果出售了 100张彩票,而且有一个进程持有了它们中的 20张,它就会有20%的机会去赢得彩票中奖。在长时间的运行中,它就会获得20%的CPU。
    • 相反, 对于优先级调度程序,很难说明拥有优先级40究竟是什么意思,这里的规则很清楚,拥有彩票f份额 的进程大约得到系统资源的f份额。
    • 如果希望进程之间协作的话可以交换它们之间的票据
    • 例如,客户端进程给服务器进程发送了一条消息 后阻塞,客户端进程可能会把自己所有的票据都交给服务器,来增加下一次服务器运行的机会。当服务 完成后,它会把彩票还给客户端让其有机会再次运行。
    • 事实上,如果没有客户机,服务器也根本不需要 彩票。

    可以把彩票理解为buff,这个buff有15%的几率能让你产生 速度之靴 的效果。

    公平分享调度

    • 到目前为止,我们假设被调度的都是各个进程自身,而不用考虑该进程的拥有者是谁。
    • 结果是,如果用 户1启动了 9个进程,而用户2启动了一个进程,使用轮转或相同优先级调度算法,那么用户1将得 到90 %的CPU时间,而用户2将之得到10 %的CPU时间。
    • 为了阻止这种情况的出现,一些系统在调度前会把进程的拥有者考虑在内。在这种模型下,每个用户都 会分配一些CPU时间,而调度程序会选择进程并强制执行
    • 因此如果两个用户每个都会有50%的 CPU时间片保证,那么无论一个用户有多少个进程,都将获得相同的CPU份额。
      在这里插入图片描述

    4.实时系统中的调度

    • 实时系统(real-time)是一个时间扮演了重要作用的系统。

    • 算机一个服务请求,而计算机必须在一个确定的时间范围内恰当的做出反应。

    • 例如,在CD播放器中的 计算机会获得从驱动器过来的位流,然后必须在非常短的时间内将位流转换为音乐播放出来。
    • 如果计算时间过长,那么音乐就会听起来有异常。
    • 再比如说医院特别护理部门的病人监护装置、飞机中的自动驾驶系统、列车中的烟雾警告装置等
    • 在这些例子中,正确但是却缓慢的响应要比没有响应甚至还糟糕。
    • 实时系统可以分为两类:硬实时(hard real time)和软实时(soft real time)系统,前者意味着必须要满足绝对的截止时间;后者的含义是虽然不希望偶尔错失截止时间,但是可以容忍

    • 在这两种 情形中,实时都是通过把程序划分为一组进程而实现的,其中每个进程的行为是可预测和提前可知的。

    • 这些进程一般寿命较短,并且极快的运行完成。在检测到一个外部信号时,调度程序的任务就是按照满 足所有截止时间的要求调度进程。

    • 实时系统中的事件可以按照响应方式进一步分类为周期性(以规则的时间间隔发生)事件或 非周期性(发生时间不可预知)事件。一个系统可能要响应多个周期性事件流,根据每个事件处理所需的时间,可能 甚至无法处理所有事件。

    例如,如果有m个周期事件,事件i以周期Pi发生,并需要Ci秒CPU时间 处理一个事件,那么可以处理负载的条件是:
    在这里插入图片描述

    • 只有满足这个条件的实时系统称为可调度的,这意味着它实际上能够被实现。一个不满足此检验标准 的进程不能被调度,因为这些进程共同需要的CPU时间总和大于CPU能提供的时间。
    • 举一个例子,考虑一个有三个周期性事件的软实时系统,其周期分别是100 ms、200 m和500 ms。
    • 如果这些事件分别需要50 ms、30ms和100 ms的CPU时间,那么该系统时可调度的,因为0.5 + 0.15 + 0.2 < 1。
    • 如果此时有第四个事件加入,其周期为1秒,那么此时这个事件如果不超过150 ms, 那么仍然是可以调度的。
    • 忽略上下文切换的时间。
    • 实时系统的调度算法可以是静态的或动态的。前者在系统开始运行之前做出调度决策;后者在运行过程中进行调度决策。只有在可以提前掌握所完成的工作以及必须满足的截止时间等信息时,静态调度才能 工作,而动态调度不需要这些限制。

    5.调度策略和机制

    • 到目前为止,我们隐含的假设系统中所有进程属于不同的分组用户并且进程间存在相互竞争CPU的情 况。
    • 通常情况下确实如此,但有时也会发生一个进程会有很多子进程并在其控制下运行的情况
    • 例如, 一个数据库管理系统进程会有很多子进程。
    • 每一个子进程可能处理不同的请求,或者每个子进程实现不 同的功能(如请求分析、磁盘访问等)。
    • 主进程完全可能掌握哪一个子进程最重要(或最紧迫),而哪一个最不重要。
    • 但是,以上讨论的调度算法中没有一个算法从用户进程接收有关的调度决策信息,这就 导致了调度程序很少能够做出最优的选择。
    • 解决问题的办法是将 调度机制(scheduling mechanism)和 调度策略(scheduling policy)分开,这是长期一贯的原则。

    • 这也就意味着调度算法在某种方式下被参数化了,但是参数可以被用户进程 填写。

    • 让我们首先考虑数据库的例子。
    • 假设内核使用优先级调度算法,并提供了一条可供进程设置优先 级的系统调用。
    • 这样,尽管父进程本身并不参与调度,但它可以控制如何调度子进程的细节。
    • 调度机制位于内核,而调度策略由用户进程决定,调度策略和机制分离是一种关键性思路

    6.线程调度

    • 当若干进程都有多个线程时,就存在两个层次的并行:进程和线程。在这样的系统中调度处理有本质的差别,这取决于所支持的是用户级线程还是内核级线程(或两者都支持)
    • 首先考虑用户级线程,由于内核并不知道有线程存在,所以内核还是和以前一样地操作,选取一个进 程假设为A,并给予A以时间片控制。
    • A中的线程调度程序决定哪个线程运行。假设为A1。
    • 由于多 道线程并不存在时钟中断,所以这个线程可以按其意愿任意运行多长时间。如果该线程用完了进程的全 部时间片,内核就会选择另一个进程继续运行。
    • 在进程A终于又一次运行时,线程A1会接着运行。该线程会继续耗费A进程的所有时间,直到它完 成工作
    • 不过,线程运行不会影响到其他进程。其他进程会得到调度程序所分配的合适份额,不会考虑 进程A内部发生的事情。
    • 现在考虑A线程每次CPU计算的工作比较少的情况
    • 例如:在50 ms的时间片中有5 ms的计算工 作。
    • 于是,每个线程运行一会儿,然后把CPU交回给线程调度程序。
    • 这样在内核切换到进程B之前,就会有序列 A1,A2,A3,A1,A2,A3,A1,A2,A3,A1。

    如下所示:
    在这里插入图片描述

    • 运行时系统使用的调度算法可以是上面介绍算法的任意一种。
    • 从实用方面考虑,轮转调度和优先级调度 更为常用。唯一的局限是,缺乏一个时钟中断运行过长的线程。但由于线程之间的合作关系,这通常也 不是问题
    • 现在考虑使用内核线程的情况,内核选择一个特定的线程运行。它不用考虑线程属于哪个进程,不过如 果有必要的话,也可以这么做。对被选择的线程赋予一个时间片,而且如果超过了时间片,就会强制挂 起该线程
    • 一个线程在50 ms的时间片内,5 ms之后被阻塞,在30 ms的时间片中,线程的顺序会 是A1,B1,A2,B2,A3,B3

    如下图所示:
    在这里插入图片描述

    • 用户级线程和内核级线程之间的主要差别在于性能用户级线程的切换需要少量的机器指令(想象一下Java程序的线程切换),而内核线程需要完整的上下文切换,修改内存映像,使高速缓存失效,这会 导致了若干数量级的延迟
    • 另一方面,在使用内核级线程时,一旦线程阻塞在I/O上就不需要在用户级 线程中那样将整个进程挂起。
    • 从进程A的一个线程切换到进程B的一个线程,其消耗要远高于运行进程A的两个线程(涉及修改内 存映像,修改高速缓存),内核对这种切换的消耗是了解到,可以通过这些信息作出决定。
    展开全文
  • HarmonyOS(鸿蒙OS)发布,聊聊操作系统调度

    万次阅读 多人点赞 2019-08-15 22:41:35
    周末台风过境时,华为终于发布了鸿蒙操作系统(HarmonyOS),我没看发布会,因为我不喜欢开发者大会出现的任何经理,所以,我在DOS玩波斯王子,魂斗罗…试图通过修改ROM调整魂斗罗到30条命… 请注意,余大嘴说...

    上周末台风过境时,华为终于发布了鸿蒙操作系统(HarmonyOS),我没看发布会,因为我不喜欢开发者大会上出现的任何经理,所以,我在DOS上玩波斯王子,魂斗罗…试图通过修改ROM调整魂斗罗到30条命…

    请注意,余大嘴说的鸿蒙OS并非仅仅指内核,他说的OS颇有Linux发行版的意思,而且更甚。华为可以在没有鸿蒙内核的情况下发布鸿蒙OS,因为PPT上说了,鸿蒙OS可以跑在安卓Linux以及鸿蒙内核之上。

    XXOS不等于XX内核,XXOS完全可以使用YY内核,就比如说GNU/Linux,GNU软件是可以跑超级多的内核上的,甚至Windows内核,GNU/Linux特指一个操作系统,该系统以Linux内核为核心,GNU软件跑在该Linux核心上。

    我不是鸿蒙生态上的应用开发者,我对开发也不感兴趣,所以本文不谈和系统生态开发有关的事,本文只是闲谈。在下面一篇文章中,我会专门通过Minix内核介绍微内核,但不是这篇。

    本文想再谈谈关于人机交互操作系统本身以及微内核,调度等操作系统比较核心的问题。


    也许,鸿蒙内核确实对调度算法进行了精心的设计,这一点是余大嘴自己说的,我也希望是这样,但是仅仅从一张PPT上也看不出什么究竟。说好的开发者大会只是展示了个PPT,肯定是要挨喷的。

    我之前在对比Windows和Linux的调度机制的时候也说过类似的,不知不觉就被怼了(不知道是我没说清,是我说错了,还是别人没有get到点,反正大多数人是没有看完就怼的,因为怼的内容和调度算法毫无关系)…不过无所谓,作为一个非科班出身的行业外部人员,从没有真正涉足过操作系统的正儿八经的研发,纯粹是兴趣能让自己有这点儿认知,已经很满足了。当然,我本身也对开发不感兴趣,所以,我不是开发者,我也不是华为的人,本文提到的鸿蒙只是一个引子,就算没有鸿蒙,没有华为,也都无所谓。

    鸿蒙也好,Windows也罢,其实都是针对用户体验的,在PC时代以及互联网时代的客户端,强调的是人机交互,在IoT时代,可能要换一个词,毕竟操作者可能不再是人了。不管怎样,作为客户端而不是进行大量运算的服务端,系统强调的东西都是一样的,这种客户端上运行的系统,我统称为 客户端操作系统 ,相对而言,UNIX/Linux这种,我称为 服务器操作系统

    • 服务端操作系统
      强调系统总体的高并发,高吞吐。
    • 客户端操作系统
      强调前台任务的低延时,快速响应。

    是的,它们非常不同,因为它们的受众不同。当然了,Windows也搞过Server版本,Linux也搞过桌面发行版,但效果都不是很好。


    在如今动不动就SMP,NUMA,众核场景,UNIX/Linux这种强调高并发的服务端系统更容易遭遇并发问题,即 锁的问题。

    可以这么说吧,服务端操作系统需要一种 自组织协作机制 ,在多个服务进程之间同时公平分配资源,每个进程都必须尽力索取资源但又不能太贪婪,设计这么一种算法是非常复杂的。

    相比之下,客户端操作系统需要是的资源的中心调配, 系统知道当前哪个进程是前台进程,谁更重要。 微内核最适合干这个了。

    我觉得微内核更像是在做资源的统一调配,而非协作式争抢。这点和PCI总线和PCIe总线之间的差异有点类似,同样的对比例子还有总线以太网和交换式以太网之间的差异。

    说白了就是仲裁,说白了就是谁能在特定时间占有资源的问题。客户端系统对这个问题的回答非常明确,但是服务端却不得不在多个并发服务之间做公平资源调配。

    • Windows可以做到将资源倾斜给前台任务,Linux不行。
    • Linux可以做到资源的公平份额调度,Windows不行。

    Linux不行的地方,Androidu也不行;Windows不行的地方,鸿蒙可能也不行。

    所以说,分开就好了嘛,根本就不是一类东西,何来对比。


    说说多核心场景Linux内核的同步问题。

    首先,让我们看看Linux内核的实时性。

    Linux内核被看作是非实时内核,这是为什么呢?

    我们知道,实时内核需要 任务的调度是可预期的 。但是Linux内核做不到,因为Linux内核中有明确的 不可抢占点 。而设置不可抢占点的权力却是所有内核代码以及驱动模块所共有的,比如,只要下面的语句:

    spin_lock(&lock);
    //...区间A
    spin_unlock(&lock);
    

    那么区间A便是不可抢占的,而区间A的执行时间不可预期,这取决于代码是怎么写的,所以实时任务即便就绪,它被调度的时间也是不可预期的。

    Linux内核的调度机制并没有规定开发者必须如何如何写代码,更没有规定不可抢占的区间的最长执行时间,所以Linux内核调度器本身便无法确保一个任务从就绪到被真正调度的最长时间,为了使这段时间原则上不会太久,Linux内核开发手册上只是定性的做了书面规定:
    spin_lock的时间不能过长。

    为什么不让调度器把所有权力收回呢?这样仅仅设计一个可以用数学证明其正确性的算法就可以满足任务调度的实时性需求了。

    spin_lock区间不可抢占的原因是可能造成死锁,特别是中断上下文本身就是不可抢占的,因此中断上下文只能用spin_lock。

    鉴于此,只需要做两点就可以完全收回调度权力了:

    1. 中断处理线程化。
    2. 可被抢占的信号量替代spin_lock。

    事实上,Linux 5.3的实时补丁就是这么做的。

    说完了Linux内核的实时性,再来看下Linux内核中锁的并发性能。

    做服务端开发的基本都曾遭遇过spin_lock热点导致CPU利用率100%的情形,为此可能还加了不少班吧。但是究竟问题的根源何在?

    在我看来,Linux的两类上下文是问题的根源:

    1. 中断上下文
    2. 进程上下文

    特别是网络收发逻辑,中断上下文的路径过长且过于复杂。关于这一点,参见:
    Linux内核UDP收包为什么效率低?能做什么优化? https://blog.csdn.net/dog250/article/details/98061338

    越是CPU核心多的环境,两类上下文的数量就越多,Linux内核作为现代操作系统内核强调进程上下文之间的隔离,而现代多队列网卡的CPU亲和性也强调cache的隔离,因此所有的两类上下文其实是无法进行协作的,因为它们之间显然不可能达到任何共识,而协作的前提就是共识。

    多个上下文在互不知情的情况下访问共享资源,不晓得别人在干什么,只能是争锁了,这非常类似于早期以太网的CSMA/CD协议,借鉴以太网此后的经验,从总线式进化到交换式以太网,其根本就是增加了一个仲裁者-交换机!

    spin_lock缺一个仲裁者!有仲裁就能有序排队,有队列就能调度,这便是微内核的优势。

    微内核将特定的工作,比如网络协议栈,比如文件系统独立成一个单独的进程,这个进程就相当于仲裁者,相当于一个交换机。

    以文件系统为例,微内核Minix2中的文件服务进程叫做FS,FS进程负责所有的整个系统的其他用户进程的文件IO服务,所有的文件操作均在这一个进程中进行,因此它便可以将不同进程的文件IO进行某种有序的排队,然后实施某种调度策略,实现有区别服务。

    微内核的文件系统进程就相当于一个交换机!
    关于微内核的话题,我接下来单独写一篇文章阐释。

    这非常不同于Linux内核作为宏内核的表现,在Linux内核中,文件IO是在各自的进程上下文中进行的,而底层的文件系统以及磁盘是共享的,无仲裁的系统只能靠锁来保证共享资源的同步访问。【如果是异步文件IO,虽摆脱了进程上下文,但同理,各个异步IO上下文无仲裁操作共享数据】

    宏内核的文件系统就相当于一条总线!

    操作系统的调度,说到底就是一系列时间和空间资源的分配问题,说起来就是这么简单,但是实施起来,这却比打铁炼钢不知难了多少倍,这是计算机科学中最美的地方,到处是trade off,又到处是trick。


    不得不再次谈谈任务调度的问题了。

    不得不说,我看过的最好的操作系统方面的教材就是《操作系统导论》了,人称OSTEP,这本书第一次将所有的调度算法按照其脉络统一了起来。其它的教材只是先简单罗列了各种调度算法的概念,然后挑个别重要的各个进行深入分析,但是基本上第二天就忘了…

    首先,N个任务,其执行时间分别为 T 1 T_1 T1 T 2 T_2 T2 T 3 T_3 T3…, T n T_n Tn,那么总体看来,在多任务系统中,所有任务总的执行时间当然是大于等于 Σ i = 0 n T i \Sigma_{i=0}^n T_i Σi=0nTi了。

    考虑到任务的总体等待时间,采用 最短任务优先 便是合理的。

    最短任务优先 落实都实现,那便是 最早完成任务优先

    平滑的算法就是一个无级变速的实现,那便是加入了 抢占 ,这便让任务的调度和任务的到达时间无关,因为调度是随时的,只要 新到达任务完成时间最近!

    然而,现实中,我们无法在一个任务确实完成之前来预评估其完成时间,所以需要某种启发式算法。

    啊哈,又是启发式算法。但是,实施某种启发式算法之前,考虑另外一个问题。


    当人们认可并选择了分时系统时,人们其实是为满足了一个特定的刚需而celebrate。
    人们更多的希望坐在终端前交互式操作计算机并随时得到反馈,而不是运行批处理,此时人们要求计算机能快速响应操作!

    于是 时间片轮转 便是一种呼之而来的算法,显而易见。

    于是,时间片轮转抢占式最早完成任务优先 结合,形成了一套还不错的理论,超级好,以至于人们希望赶紧实现它!

    然而,回到最初的问题,人们无法预估任务的完成时间,于是现实的算法成了:
    时间片轮转+启发式算法

    这就是 多级反馈优先级队列 了。可以说,多级反馈队列由时间片轮转+启发式算法演化而来的,它试图满足最短任务优先的要求

    多级反馈队列算法将新任务放在最高优先级上,如果一个任务是一个短任务,那么它将很快结束,符合 最短任务优先 的约束,如果这是一个长任务,那么它将逐步下降到更低的优先级,最终被判定为长任务,依然符合约束,因此,多级反馈队列算法是一个自适应的算法。


    通过研究各种主流的操作系统调度算法,我们发现,Window的调度算法更像是标准的多级反馈队列,而linux内核不是。

    干嘛非要把一个进程的生命周期看作是一个任务的始终?把一个进程的两次不得已的IO间隔当成一个任务不更好吗?嗯,Windows看来就是这么做的。

    最早完成任务优先+抢占式时间片轮转调度 ,它们和Windows的GUI交互行为结合在一起,辅助以 优先级提升 ,便成就了 GUI操作超级流畅不卡顿的Windows

    反观Linux内核调度,虽然也伴随有 动态优先级提升或者降低 ,但是却丝毫没有表现出 多级反馈队列 的特征,不信请去自行分析 O ( 1 ) O(1) O(1)算法源码。


    如果以任意任务连续两次IO之间的执行绪作为一个任务,最早结束任务优先,以两次IO间隔为期,大概率,交互应用基本都是在IO完成后迅速完成,这种行为完全符合上述的算法描述,加上时间片(加入一个进程肯定要拖慢处理器其时间单位,这无可厚非)轮转,这已经基本将处理器对待任务的周转时间榨取到了极致。唯一无法预测的问题,就是交互进程下一次IO何时进行,因此,多级反馈队列是预测好不好的问题,而不是对不对的问题。

    嗯,像以上的描述,调度理论基本上就统一在了一个一致的需求框架里,Linux和Windows竟然能和该框架完全匹配的上,不错。

    关于OSTEP这本书,这里有个链接:https://github.com/EmbedXj/OperatingSystems.ThreeEasyPieces
    它是一个OSTEP的翻译计划,尝试将《操作系统导论》这本书翻译成中文,不过,由于该书 中文版已经出版,该计划项目已经由发起者本人宣布停止。


    浙江温州皮鞋湿,下雨进水不会胖。

    展开全文
  • OS进程调度实验

    2017-05-08 21:17:38
    OS进程调度实验 模拟优先级时间片调度

    OS进程调度实验

    一、实验目的
    通过实验加强对进程调度算法的理解和掌握。
    二、实验内容
    编写程序实现基于优先级的时间片轮转调度算法。
    三、实验要求
    1、假定系统有5个进程,每个进程用一个进程控制块PCB来代表,进程控制块的结构如下图1.1所示:

    进程名
    优先级
    要求运行时间
    已运行时间
    进程状态
    指针
    
    其中:
    进程名:作为进程的标识,假设五个进程的进程名分别为p1,p2,p3,p4,p5。
    指针:进程按顺序排成循环链表,用指针指出下一个进程的进程控制块首地址,最后一个进程中的指针指出第一个进程的进程控制块首地址。
    要求运行时间:假设进程需要运行的单位时间数。
    已运行时间:假设进程已经运行的单位时间数,初值为0。
    状态:可假设有两种状态,就绪状态和结束状态。进程的初始状态都为就绪状态。
    

    2、每次运行所设计的处理器调度程序调度进程之前,为每个进程随机确定它的要求运行时间。
    3、此程序是模拟处理器调度,因此,被选中的进程并不实际启动运行,而是执行

    已运行时间+1
    来模拟进程的一次运行,表示进程已经运行过一个单位时间。
    

    4、在所设计的程序中应有显示语句,能显示每次被选中的进程名以及运行一次后进程队列的变化。

    • 再次犯错了!pre是指针变量,可以修改pre向的内容,但修改pre的指向是不会影响外部的!
      PCB*getHp(PCB *pre);
    • code:
    #include<iostream>
    #include<cstring>
    #include<cstdlib>
    using namespace std;
    struct PCB{
    	char name[20];
    	int priority;
    	int all_time;
    	int run_time;
    	int status;//1 ready 0 stop
    	PCB* next;
    	PCB(){
    		priority=0;
    		all_time=run_time;
    		status=1;
    	}
    };
    const int piece=10;
    PCB *pcb=NULL;
    PCB* getHp(PCB* pre);
    void  create(PCB*p)
    {
    	if(pcb==NULL)
    	{
    	  pcb=p;
    	  pcb->next=pcb;
    	}
    	PCB*pn=pcb;
    	while(pcb!=pn->next)pn=pn->next;
    	pn->next=p;
    	p->next=pcb;
    }
    void run()
    {
    	PCB*pre=pcb;
    	PCB*p=pcb->next;
    	while(pcb!=NULL)
    	{
    		pre=getHp(pre);
    		p=pre->next;
    		cout<<p->name<<" is running!"<<endl;
    		int i=0;
    		while(++i)
    		{
    		    p->run_time++;
    			if(p->run_time>=p->all_time)
    			{
    				cout<<p->name<<" over!"<<"all_time"<<  \
    					p->all_time<<" running time:"<<p->run_time<<endl;
    				p->status=0;
    				if(p->next==p)
    				{
    					delete p;
    					pcb=NULL;
    					break;
    				}else
    				{
    					PCB*pdone=p;
    					pre->next=p->next;
    					p=p->next;
    					delete pdone;
    					break;
    				}
    			}else if(i>piece)//
    			{
    				cout<<"piece time done!"<<endl;
    				pre=pre->next;
    				p=pre->next;
    				break;
    			}
    		}
    	}
    	cout<<"no process is running!"<<endl;
    }
    //ret:next param:pre-pre of next
    //pre->next==p
    //再次犯错了!pre是指针变量,可以修改pre向的内容,但修改pre的指向是不会影响外部的!
    PCB*getHp(PCB *pre)
    {
    	PCB*hp=pre;//记录优先级最高的pcb
    	PCB*pn=pre->next;//迭代
    	while(pre!=pn)
    	{
    		if(pn->next->priority>hp->next->priority)
    		  hp=pn;
    		pn=pn->next;
    	}
    	pre=hp;
    	return pre;
    }
    int main()
    {
    	cout<<"---------create process---------"<<endl;
    	char name[5]="pc0";
    	for(int i=0;i<5;i++)
    	{
    		PCB* p=new PCB();
    		p->priority=rand()%10;
    		name[2]='0'+i;
    		strcpy(p->name,name);
    		p->all_time=rand()%50;
    
    		cout<<p->name<<" priority:"<<p->priority<<"`all_time:"<<p->all_time<<endl;
    		create(p);
    	}
    	cout<<"------------run---------------"<<endl;
    	//时间片
    	run();
    
    	cout<<"------------exit---------------"<<endl;
    	return 0;
    }
    /*
    output:
    ---------create process---------
    pc0 priority:3`all_time:36
    pc1 priority:7`all_time:15
    pc2 priority:3`all_time:35
    pc3 priority:6`all_time:42
    pc4 priority:9`all_time:21
    ------------run---------------
    pc4 is running!
    piece time done!
    pc4 is running!
    pc4 over!all_time21 running time:21
    pc1 is running!
    piece time done!
    pc1 is running!
    pc1 over!all_time15 running time:15
    pc3 is running!
    piece time done!
    pc3 is running!
    piece time done!
    pc3 is running!
    piece time done!
    pc3 is running!
    pc3 over!all_time42 running time:42
    pc0 is running!
    piece time done!
    pc2 is running!
    piece time done!
    pc0 is running!
    piece time done!
    pc2 is running!
    piece time done!
    pc0 is running!
    piece time done!
    pc2 is running!
    piece time done!
    pc0 is running!
    pc0 over!all_time36 running time:36
    pc2 is running!
    pc2 over!all_time35 running time:35
    no process is running!
    ------------exit---------------;
     */
    
    展开全文
  • OS-调度

    2020-12-22 15:11:17
    操作系统作业 - 调度 1. 阐述最高响应比优先调度算法的主要优点和缺点 最高响应比优先调度算法(Highest Response Ratio Next)是周转时间和实际服务时间的比值,即: 响应比=(等待时间+服务时间)/服务时间 ...
  • OS进程调度及典型调度算法

    千次阅读 2017-05-03 21:11:07
    记录系统中的所有进程的状态、优先级数和资源的需求情况 确定调度算法,决定将CPU分配给哪个进程多少时间 分配处理机给进程,进行CPU现场的保护和移交 调度的层次一个作业从提交开始直到完成,往往要经历以下三级...
  • os任务调度实现原理

    千次阅读 2019-07-06 21:07:17
    操作系统中最为显著的特性就是任务调度,任务调度主要来自于以下几种需求: 程序并发(multiprogram) 任务间同步、消息传递 实时性能要求 其中第一点程序并发很好理解,对于一般意义的单核硬件平台而言...
  • 考虑一台具有1-CPU和固定大小内存的计算机(可以更改1024 ==>)。 我们的调度程序实现了如下图所示的补充组件。 :pushpin: 笔记: 我们支持以下调度算法: HPF(最高优先级优先) STRN(接下来最短的时间) RR...
  • TencentOS-tiny快一年了,不像FreeRTOS 等国外的实时系统那么完善,但是,绝对是入门实时系统的不二之选。内部集成CoAP/MQTT/TLS/DTLS/LoRaWAN/NB-IoT等物联网协议栈。近两年物联网技术应用广泛,各个巨头都想在物联...
  • Zephyr OS之内核调度

    2017-04-24 22:17:46
    第2章 内核调度 2.1 线程调度概念  zephyr内核是基于优先级抢占,时间片分配的实时操作系统。...在操作系统术语里,称为切换下文。 2.1.1 当前线程  CPU当前正在运行的线程,称之为当前线程(curre
  • 为了从 Linux 服务器榨取尽可能多的性能,请了解如何更改 I/O 调度器以满足你的需求。Linux I/O 调度器(Linux I/O scheduler)控制内核提交读写请求给磁盘的方式。自从 2.6 内核以来,管理员已经能够更改这个调度器,...
  • OS】处理机调度

    2020-08-08 11:38:36
    文章目录调度概念处理机三层调度调度的时机、切换与过程进程调度方式调度基本准则 调度概念 调度的概念 在多道程序系统中,进程的数量往往多于处理机的个数,...又称高级调度,其主要任务是按一定的原则从外存处于
  • Golang中的调度(1):OS调度器 - OS Scheduler Golang中的调度(2):Go调度器 - Go Scheduler Golang中的调度(3):并发- Concurrency 本部分内容主要讨论操作系统层次的调度器工作机制。 引言 Go调度器能使...
  • 在多道批处理系统中,一个作业从提交到获得CPU执行,直到作业运行完毕,可能需要经历多级处理机调度。 一、处理机调度的层次 1. 高级调度(作业调度 / 长程调度调度对象: 作业 功能: 根据某种算法,将后备队列...
  •  为了标识当前系统中哪些任务(该任务由优先级标识)处于就绪状态,以便于系统调度时可以快速地访问到处于就绪状态的最高优先级的任务,操作系统定义了以下两个全局变量以构成任务就绪表,用以标识所有处于...
  • 处理器调度的过程就是为待处理的作业或进程分配...然后为被选中的作业创建进程,并分配必要的系统资源,如内存、外设等。最后把新创建的进程放入就绪队列中,等待被调度执行。高级调度的时间尺度通常是分钟、小时或天。
  • 一、结构体类型:   图1   ...如上图1,task_list是任务节点的结构体,具体参数如下: ... 1、task_id是任务ID... 调度系统下载链接如下:  https://download.csdn.net/download/moonlinux20704/12073629  
  • 记录系统中的所有进程的状态、优先级数和资源的需求情况确定调度算法,决定将CPU分配给哪个进程多少时间分配处理机给进程,进行CPU现场的保护和移交 调度的层次 一个作业从提交开始直到完成,往往要经历以下三...
  • **根据时间片轮转调度在同优先级任务中的应用,需要对 任务的TCB进行修改,增加4个属性项:** 1)OSTSLen(时间片初始值)。保存任务建立时给任务分 配时间片的个数。 2)OSTSCurLen(时间片剩余值)。记录了任务运行...
  • 2.调度程序周期性地修改优先级(避免饥饿) 实时进程: 1.采用静态优先级来调度; 2.由用户预先指定,以后不会改变. 静态优先级: 进程创建时指定或用户修改 动态优先级: 进程运行期间可以按照调度策略改变 非实时进程...
  • 2019年8月9日,华为消费者业务今天在其全球开发者大会正式向全球发布其全新的基于微内核的面向全场景的分布式操作系统——鸿蒙OS。【PChome资讯报道】2019年8月9日下午,华为消费者业务今天在其全球开发者大会...
  • 针对传感器网络操作系统TinyOS无法保证任务实时性的缺陷,提出一种自适应双环调度(ADRS)策略,并在TinyOS上加以实现。自适应双环调度策略将先到先服务(FCFS)调度策略下的单循环队列改为具有不同优先级别的双循环...
  • 项目背景: 最近公司在做一个ODM项目,需要把公司内部的协议栈交互与加密...因为公司协议栈内部有交互(设备与APP之间有命令交互和阻塞等待超时等场景),因此需要制作一个跨平台的调度机制,又能保证性能和兼容性...
  • go语言最大的卖点在于并发编程,尤其是现在免费...将分3篇文章进行讲述,分别是OS调度器,GO调度器以及如何进行并发编程. 介绍 Go调度器的设计和行为能够让Go多线程程序的编写更加高效和具有更高的性能。这要得益...
  • OS_RdyListRemove() 函数将当前任务从任务就绪列表中移除,并将系统切换至其他任务。 OSTimeDlyResume () 函数用于直接结束其他任务(非当前任务)的延时 OSTimeGet () 函数用于获取当前的时钟节拍计数值 OSTimeSet ...
  • Kubernetes — 调度系统

    2020-11-22 14:23:15
    文章目录目录Kubernetes 调度系统的未来Scheduler Extender(调度器扩展)Multiple Schedulers(多调度器)Kubernetes Scheduling Framework(调度框架)Scheduling CycleBinding Cycle基于 scheduler-plugins 实现...
  • 基于µC/OS-II的时间片调度法设计

    千次阅读 2012-09-26 16:37:21
    摘要 多任务的调度算法多种多样,各种调度算法也各有千秋。在某些应用场合,时间片调度法就比纯粹的优先级调度法更具优势。本文提出了基于µC/OS-II的时间片调度法的设计...µC/OS-II嵌入式实时操作系统采用的是基于
  • 内核概述: 多任务系统中,内核负责管理各个任务,或者说为每个任务分配CPU时间,并且负责任务之间的通讯。内核提供的基本服务是任务切换。之所以使用实时内核可以大大简化应用系统的设计,是因为实时内核允许将...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 53,178
精华内容 21,271
关键字:

os上系统调度修改