精华内容
下载资源
问答
  • 操作系统处理机调度

    2018-01-20 01:30:13
    操作系统处理机调度实验源代码,内含详细注释!包括多种处理机调度方法:先来先服务、最短作业优先、最高响应比优先、时间片轮转、优先级法
  • 操作系统处理机调度读书报告操作系统处理机调度读书报告操作系统处理机调度读书报告
  • 操作系统 处理机调度的有意思的课件,处理机调度采取动画方式展示
  • java语言实现操作系统处理机调度
  • 操作系统处理机调度算法模拟实现

    千次阅读 2017-11-25 18:53:55
    操作系统处理机调度算法模拟实现

    简介

      多道程序设计中,经常是若干个进程同时处于就绪状态,为了使系统中的各进程有条不紊地运行,必须选择某种调度策略,以选择一个进程占用处理机。

    思路分析

      由于本实验是按照处理机调度算法模拟实现处理机的调度,与真正的处理机调度过程不完全相同,比如没有实现中断,进程的运行也不是真正的运行,而是在屏幕上打印其运行时间等。

    大致思路:

    • 建立三个队列:PCB队列,就绪队列,完成队列。
      • PCB队列:保存将进入系统的进程。(由于没有实现中断,所以将进入系统运行的进程必须在程序运行前给出)。
      • 就绪队列:到达进程进入系统的时间,将该进程放入就绪队列,等待调度。
      • 完成队列:将“运行”完的进程放入完成队列。
    • 进程运行过程是在屏幕上打印相关信息。
      • 使用轮转算法调度的进程应打印的信息包括:进程占用处理机序列,该进程每次占用处理机的开始时间与结束时间。
    • 统计出进程的周转时间T和带权周转时间W。

    大致流程图

    这里写图片描述

    实现

    public class OSRR {
        public static void main(String[] args) {
            new RR();
        }
    }
    
    class RR {
        private Queue<RRBean> PCBQueue;
        private LinkedList<RRBean> ReadyQueue;
        private Queue<RRBean> CompleteQueue;
        // 定义时间片的长度
        private static final int SLICETIME = 4;
        // 定义总的运行时间
        private int time;
    
        RR() {
            time = 0;
            InitQueue();
            InitBean();
            StartProcess();
            showResult();
        }
    
        private void StartProcess() {
            System.out.println("PCB进程数" + PCBQueue.size());
            StringBuilder sb = new StringBuilder();
            sb.append("运行过程:");
            while (true) {
                // 是否所有进程运行完
                if (PCBQueue.size() == 0 && ReadyQueue.size() == 0) {
                    // 如果所有进程都运行完了,就终止程序
                    break;
                }
                // 是否有新的进程进入系统
                for (RRBean r : PCBQueue) {
                    // 新的进程进入就绪队列
                    if (r.arrive_time <= time) {
                        ReadyQueue.addFirst(r);
                        PCBQueue.remove(r);
                        break;
                    }
                }
    
                // 就绪队列不为空的时候
                if (ReadyQueue.size() != 0) {
                    // 取出一个进程运行
                    RRBean r = ReadyQueue.poll();
                    r.run_time += SLICETIME;
                    int temp = time;
                    // 如果时间片用完之后,
                    if (r.run_time >= r.time) {
                        time += r.time - r.run_time + SLICETIME;
                        r.endTime = time;
                        // 该进程已经完成了
                        CompleteQueue.offer(r);
                    } else {
                        time += SLICETIME;
                        // 该进程没有完成
                        ReadyQueue.offer(r);
                    }
                    System.out.println("进程号:" + r.id +
                            ",本次开始时间:" + temp + ",本次结束时间:" + time);
                    sb.append(r.id);
                    sb.append("->");
                } else {
                    ++time;
                }
            }
            sb.delete(sb.length() - 2, sb.length());
            System.out.println(sb.toString());
        }
    
        private void showResult() {
            System.out.println("××××××××最后的结果:××××××××");
            for (RRBean rrBean : CompleteQueue) {
                System.out.println("进程号:" + rrBean.id + ",周转时间为:" +
                        (rrBean.endTime - rrBean.arrive_time) + ",平均周转时间:" +
                        (float) (rrBean.endTime - rrBean.arrive_time) / rrBean.time);
            }
        }
    
    
        private void InitQueue() {
            PCBQueue = new LinkedList<>();
            ReadyQueue = new LinkedList<>();
            CompleteQueue = new LinkedList<>();
        }
    
        private void InitBean() {
            File file = new File("./src/Schedule/rr1.txt");
            BufferedReader br = null;
            String read;
            try {
                System.out.println("进程ID\t到达时间\t估计运行时间\t优先级");
                br = new BufferedReader(new FileReader(file));
                while ((read = br.readLine()) != null) {
                    RRBean rrBean = new RRBean();
                    rrBean.init(read);
                    PCBQueue.offer(rrBean);
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
                System.out.println("文件不存在");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (br != null) {
                    try {
                        br.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    
    class RRBean {
        //进程号
        int id;
        //进程状态  0-Ready,  1-Run,  2-Finish
        int status;
        //进程到达时间
        int arrive_time;
        //估计运行时间
        int time;
        //已运行时间
        int run_time;
        //等待时间
        int wait_time;
        //优先级
        int priority;
        // 结束时间
        int endTime;
    
        void init(String initString) {
            List<String> num = new ArrayList<>();
            Pattern pattern = Pattern.compile("-*\\d+(\\.\\d+)?");
            Matcher matcher = pattern.matcher(initString);
            while (matcher.find()) {
                num.add(matcher.group());
            }
            StringBuilder sb = new StringBuilder();
            for (String string : num) {
                sb.append(string);
                sb.append("\t\t");
            }
            System.out.println(sb.toString());
            this.id = Integer.parseInt(num.get(0));
            this.arrive_time = Integer.parseInt(num.get(1));
            this.time = Integer.parseInt(num.get(2));
            this.priority = Integer.parseInt(num.get(3));
            this.status = 0;
            this.run_time = 0;
            this.wait_time = 0;
        }
    }

    情况1

      备注:进程ID、到达时间、估计运行时间、优先级

    0     2   30    2
    1     2   60    4
    2     15   15    0
    3     26   28    5
    4     80   19    1
    5     90   8     7

      输出结果:(备注:时间片为10)

    进程ID    到达时间    估计运行时间  优先级
    0       2       30      2       
    1       2       60      4       
    2       15      15      0       
    3       26      28      5       
    4       80      19      1       
    5       90      8       7       
    PCB进程数6
    进程号:0,本次开始时间:2,本次结束时间:12
    进程号:1,本次开始时间:12,本次结束时间:22
    进程号:2,本次开始时间:22,本次结束时间:32
    进程号:3,本次开始时间:32,本次结束时间:42
    进程号:0,本次开始时间:42,本次结束时间:52
    进程号:1,本次开始时间:52,本次结束时间:62
    进程号:2,本次开始时间:62,本次结束时间:67
    进程号:3,本次开始时间:67,本次结束时间:77
    进程号:0,本次开始时间:77,本次结束时间:87
    进程号:4,本次开始时间:87,本次结束时间:97
    进程号:5,本次开始时间:97,本次结束时间:105
    进程号:1,本次开始时间:105,本次结束时间:115
    进程号:3,本次开始时间:115,本次结束时间:123
    进程号:4,本次开始时间:123,本次结束时间:132
    进程号:1,本次开始时间:132,本次结束时间:142
    进程号:1,本次开始时间:142,本次结束时间:152
    进程号:1,本次开始时间:152,本次结束时间:162
    运行过程:0->1->2->3->0->1->2->3->0->4->5->1->3->4->1->1->1
    ××××××××最后的结果:××××××××
    进程号:2,周转时间为:52,平均周转时间:3.4666667
    进程号:0,周转时间为:85,平均周转时间:2.8333333
    进程号:5,周转时间为:15,平均周转时间:1.875
    进程号:3,周转时间为:97,平均周转时间:3.4642856
    进程号:4,周转时间为:52,平均周转时间:2.7368422
    进程号:1,周转时间为:160,平均周转时间:2.6666667

    情况2

      
      备注:进程ID、到达时间、估计运行时间、优先级

    0     0   4    2
    1     1   3    4
    2     2   4    0
    3     3   2    5
    4     4   4    1

      输出结果:(备注:时间片为1)

    进程ID    到达时间    估计运行时间  优先级
    0       0       4       2       
    1       1       3       4       
    2       2       4       0       
    3       3       2       5       
    4       4       4       1       
    PCB进程数5
    进程号:0,本次开始时间:0,本次结束时间:1
    进程号:1,本次开始时间:1,本次结束时间:2
    进程号:2,本次开始时间:2,本次结束时间:3
    进程号:3,本次开始时间:3,本次结束时间:4
    进程号:4,本次开始时间:4,本次结束时间:5
    进程号:0,本次开始时间:5,本次结束时间:6
    进程号:1,本次开始时间:6,本次结束时间:7
    进程号:2,本次开始时间:7,本次结束时间:8
    进程号:3,本次开始时间:8,本次结束时间:9
    进程号:4,本次开始时间:9,本次结束时间:10
    进程号:0,本次开始时间:10,本次结束时间:11
    进程号:1,本次开始时间:11,本次结束时间:12
    进程号:2,本次开始时间:12,本次结束时间:13
    进程号:4,本次开始时间:13,本次结束时间:14
    进程号:0,本次开始时间:14,本次结束时间:15
    进程号:2,本次开始时间:15,本次结束时间:16
    进程号:4,本次开始时间:16,本次结束时间:17
    运行过程:0->1->2->3->4->0->1->2->3->4->0->1->2->4->0->2->4
    ××××××××最后的结果:××××××××
    进程号:3,周转时间为:6,平均周转时间:3.0
    进程号:1,周转时间为:11,平均周转时间:3.6666667
    进程号:0,周转时间为:15,平均周转时间:3.75
    进程号:2,周转时间为:14,平均周转时间:3.5
    进程号:4,周转时间为:13,平均周转时间:3.25

      输出结果:(备注:时间片为4)

    进程ID    到达时间    估计运行时间  优先级
    0       0       4       2       
    1       1       3       4       
    2       2       4       0       
    3       3       2       5       
    4       4       4       1       
    PCB进程数5
    进程号:0,本次开始时间:0,本次结束时间:4
    进程号:1,本次开始时间:4,本次结束时间:7
    进程号:2,本次开始时间:7,本次结束时间:11
    进程号:3,本次开始时间:11,本次结束时间:13
    进程号:4,本次开始时间:13,本次结束时间:17
    运行过程:0->1->2->3->4
    ××××××××最后的结果:××××××××
    进程号:0,周转时间为:4,平均周转时间:1.0
    进程号:1,周转时间为:6,平均周转时间:2.0
    进程号:2,周转时间为:9,平均周转时间:2.25
    进程号:3,周转时间为:10,平均周转时间:5.0
    进程号:4,周转时间为:13,平均周转时间:3.25
    展开全文
  • 操作系统处理机调度实验报告,内含C语言程序,流程框图,说明
  • 处理机调度算法实验报告 学 号 姓 名 时 间 专 业 班 级 实验题目处理机调度算法 一实验目的 在了解操作系统的基础上全面了解处理机调度算法的实现以及过程 详细了解处理机调度算法的机制充分了解调度的过程及状态...
  • 操作系统的课程设计 处理机调度模拟程序 进程调度:时间片轮转法 最短作业优先 动态优先级
  • 系统包含了所有的操作体统的处理机调度算法,采用c++语言设计。
  • 操作系统处理机调度及常见的调度算法(先来先服务调度算法(FCFS),短作业(进程)优先调度算法,高优先权优先调度算法,时间片轮转算法)

    一.处理机调度的层次:

    1.高级调度:高级调度又称为作业调度或长程调度,其主要功能是根据某种算法,把外存上处于后备队列中的那些作业调入内存,也就是说,它的调度对象是作业。

    2.中级调度:中级调度又称中程调度。引入中程调度的主要目的是为了提高内存利用率和系统吞吐量。中级调度实际上就是存储器管理中的对换功能。

    3.低级调度:低级调度通常也称为进程调度或短程调度,它所调度的对象是进程(或内核级线程),进程调度是最基本的一种调度,在多道批处理,分时,实时三种类型的OS中,

                            都必须配置这级调度。

    二.调度队列模型:

    1.仅有进程调度的调度队列模型:


    2.具有高级和低级调度的调度队列模型:


    3.同时具有三级调度的调度队列模型:


    三.调度算法:

    1.先来先服务和短作业(进程)优先调度算法

    (1)先来先服务调度算法(FCFS):

            先来先服务调度算法是一种最简单的调度算法,该算法即可用于作业调度,也可用于进程调度。当在作业调度中采用该算法时,每次调度都是从后备作业队列中选择一个

    或多个最先进入该队列的作业,将它们调入内存,为它们分配资源,创建进程,然后放入就绪队列。在进程调度中采用FCFS算法时,则每次调度是从就绪队列中选择一个最先

    进入该队列的进程,为之分配处理机,使之投入运行。该进程一直运行到完或发生某事件而阻塞后才放弃处理机。

            FCFS算法比较有利于长作业(进程),而不利于短作业(进程)。

    (2)短作业(进程)优先调度算法:

            短作业(进程)优先调度算法SJ(P)F,是指对短作业或短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先(SJF)的调度算法是从后备队列

    中选择一个或若干个估计运行时间最短的作业,将它们调入内存运行。而短进程(SPF)调度算法则是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使

    它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机再重新调度。

            优点:SJ(P)F调度算法能有效地降低作业(进程)的平均等待时间,提高系统吞吐量。

            缺点:1>该算法对长作业不利;

                        2>完全未考虑作业的紧迫程度,因而不能保证紧迫性作业(进程)长期不被调度;

                        3>由于作业(进程)的长短只是根据用户所提供的估计执行时间而定的,而用户又可能会有意或无意地缩短其作业的估计运行时间,致使该算法不一定能真正做到  

                             短作业优先调度;

    实例:



    2.高优先权优先调度算法:

    优先级调度的含义:

       # 当该算法用于作业调度时,系统从后备作业队列中选择若干个优先级最高的,且系统能满足资源要求的作业装入内存运行。

       # 当该算法用于进程调度时,将把处理机分配给就绪进程队列中优先级最高的进程。

    优先权调度算法的类型:

    (1)非抢占式优先级算法:

             在这种调度方式下,系统一旦把处理机分配给就绪队列中优先级最高的进程后,该进程就能一直执行下去,直至完成;或因等待某事件的发生使该进程不得不放弃处理机

    时,系统才能将处理机分配给另一个优先级高的就绪进程。

    使用场合:主要用于一般的批处理系统、分时系统,也常用于某些实时性要求不太高的实时系统。

     (2)抢占式优先级调度算法:

             在这种调度方式下,进程调度程序把处理机分配给当时优先级最高的就绪进程,使之执行。一旦出现了另一个优先级更高的就绪进程时,进程调度程序就停止正在执行的

    进程,将处理机分配给新出现的优先级最高的就绪进程。

    使用场合:常用于实时要求比较严格的实时系统中,以及对实时性能要求高的分时系统。      

    优先级的类型:进程的优先级可采用静态优先级和动态优先级两种,优先级可由用户自定或由系统确定。

    (1)静态优先权:静态优先级是在创建进程时确定进程的优先级,并且规定它在进程的整个运行期间保持不变。

    确定优先级的依据:①进程的类型。通常系统进程优先级高于一般用户进程的优先级;交互型的用户进程的优先级高于批处理作业所对应的进程的优先级。

                                        ②进程对资源的需求。例如,进程的估计执行时间及内存需求量少的进程,应赋于较高的优先级,这有利缩小作业的平均周转时间。

                                        ③根据用户的要求。用户可以根据自己作业的紧迫程度来指定一个合适的优先级。

    优点:①简单易行 ②系统开销小

    缺点:①不太灵活,很可能出现低优先级的作业(进程),长期得不到调度而等待的情况。

                ②静态优先级法仅适用于实时要求不太高的系统。

    (2)动态优先级:动态优先级是在创建进程时赋予该进程一个初始优先级,然后其优先级随着进程的执行情况的变化而改变,以便获得更好的调度性能。

    优缺点:动态优先级优点是使相应的优先级调度算法比较灵活、科学,可防止有些进程一直得不到调度,也可防止有些进程长期垄断处理机。动态优先级缺点是需要花费相当多

    执行程序时间,因而花费的系统开销比较大。

    3.基于时间片的轮转调度算法

    时间片轮转算法:

            时间片轮转调度是一种最古老,最简单,最公平且使用最广的算法。每个进程被分配一个时间段,称作它的时间片,即该进程允许运行的时间。如果在时间片结束时进程正

    在运行,则CPU将被剥夺并分配给另一个进程。如果进程在时间片结束前阻塞或结束,则CPU当即进行切换。调度程序所要做的就是维护一张就绪进程列表,当进程用完它的

    时间片后,它被移到队列的末尾。

            时间片轮转调度中唯一有趣的一点是时间片的长度。从一个进程切换到另一个进程是需要一定时间的--保存和装入寄存器值及内存映像,更新各种表格和队列等。假如进程

    切换(process switch) - 有时称为上下文切换(context switch),需要5毫秒,再假设时间片设为20毫秒,则在做完20毫秒有用的工作之后,CPU将花费5毫秒来进行进程切换。

    CPU时间的20%被浪费在了管理开销上。

    原理:在早期的时间片轮转法中,系统将所有的就绪进程按先来先服务的原则,排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片,时间片的大小从

    几ms到几百ms。当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就

    绪队列中新的队首进程,同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程,在一给定的时间内,均能获得一时间片的处理机执行时间。

    实例:



    展开全文
  • 很不错的处理机调度课程设计,分享一下,还望大家多多支持,word文档格式。
  • 本人写的处理机调度c++小程序,有3个,分别是先来先服务,优先级和时间片轮转这三个算法
  • 选择一个调度算法,实现处理机调度。 二、实验目的 多道系统中,当就绪进程数大于处理机数时,须按照某种策略决定哪些进程优先占用处理机。本实验模拟实现处理机调度,以加深了解处理机调度的工作。 三、实验题目 ...
  • 采用MFC模拟实现OS处理机调度算法的实现,先来先服务、短作业优先、基于时间片的轮转、多级反馈队列调度算法。
  • 进程调度算法的数据结构主要有:进程函数定义,建立进程函数,进程调度函数。
  • 这是操作系统两个实验的综合,用java做到,采用图形界面,打包成了jar文件,继而做成了exe安装文件,内置完整的帮助,对于刚学操作系统的新手很有帮助。在xp和jdk1.6下运行通过,我还在继续完善,没有上java源代码(*...
  • 操作系统处理机调度的基本概念、调度算法和死锁及处理。
  • 操作系统处理机调度算法

    千次阅读 多人点赞 2018-06-21 17:26:21
    处理机调度算法 在多道程序系统中,调度实际上是一种资源分配,即对处理机资源的分配;处理机调度算法是指根据处理机分配策略所规定的处理机分配方法; 处理机调度 处理机调度的层次 高级调度 高级调度又...

    处理机调度算法


    在多道程序系统中,调度实际上是一种资源分配,即对处理机资源的分配;处理机调度算法是指根据处理机分配策略所规定的处理机分配方法;

    处理机调度

    处理机调度的层次

    1. 高级调度

      高级调度又称为长程调度或者作业调度;其调度对象是作业;主要功能是根据调度算法决定从外存中的后备队列中选择哪几个作业调入内存,为它们创建进程、分配必要的资源,然后将其放入就绪队列。高级调度主要用于多道批处理系统中,在分时系统和实时系统中不设置高级调度;

    2. 低级调度

      低级调度又称为短程调度或者进程调度;其调度的对象是进程;主要功能是根据调度算法决定哪个进程可以获得处理机而运行,由分派程序将处理机分配给被选中的进程;进程调度是一种基本调度,多道批处理系统、分时系统和实时系统都需要设置这种调度;

    3. 中级调度

      中级调度又称为中程调度或者内存调度;其调度对象是进程;主要功能是将暂时不能运行的进程调至外存等待,此时进程即处于就绪驻外存状态(挂起状态);当它们具备运行条件而且内存空间又允许的时候,由中级调度来决定把处于外存上的那些具备运行条件的就绪进程再调入内存,修改其状态为就绪状态; 中级调度其实就是存储器管理中的对换功能。

    长程调度、中程调度以及短程调度是根据程序的运行频率和周期来划分的;长程调度运行频率最低,所以其周期较长;短程调度最为频繁,为避免调度本身占用过多CPU时间,其调度算法不能过于复杂,即运行周期最短;而中程调度不论运行频率还是运行周期都在两者之间;

    处理机调度算法的目标

    一般而言,一个操作系统采用什么样的调度方式和算法,取决于系统的类型以及设计目标;

    处理机调度算法的共同目标

    1. 资源利用率。为提高系统资源的利用率,应使系统中的处理机和其它所有资源都尽可能的处于忙碌状态;其中CPU的利用率可以使用该式计算:CPU的利用率=CPU的有效工作时间/(CPU有效工作时间+CPU空闲等待时间);
    2. 公平性。公平性是指应使各个进程都获得合理的CPU时间,不会发生进程饥饿现象;但是公平是相对的,即同一类进程应获得相同的服务,但是不同类的进程由于进程的紧急程度或者重要性不同,则应区别对待;
    3. 平衡性。系统中的资源多种多样,有的属于计算型作业,有的属于IO型,调度算法应使系统资源的使用保持平衡;
    4. 策略强制执行。对于所制定的策略,如安全策略,只要需要,就必须准确地执行;

    批处理系统的目标

    1. 平均周转周期短。作业的周转周期是指从作业提交给系统到作业完成为止这段时间;周转周期通常由四部分组成:作业在外存上后备队列中的等待时间、进程在就绪队列中的时间、执行时间和等待IO操作等阻塞的时间;

      对于用户而言,希望自己的作业周转周期尽可能地短;对于系统而言,希望作业的平均周转周期短,这样不但有利于提高系统资源的利用率也可以使大多数用户满意;总的来说,应使作业的周转周期和平均周转周期都较短;

      平均周转周期T=(所有作业的周转周期之和)/作业总数;

      为了进一步反映调度的性能,更清晰地描述进程在其周转时间中等待和执行时间的具体分配状况,通常使用加权周转时间W,即作业的周转时间T与系统为它提供服务的时间Ts之比:W=T/Ts;平均加权周转周期为各个作业的加权周转时间之和/作业总数;

    2. 系统吞吐量大。如果单纯为了提高系统的吞吐量,应尽量执行较短的作业运行;吞吐量被定义为单位时间里,系统完成的作业数;

    3. 处理机效率高。由于CPU十分昂贵,使得处理机的利用率成为衡量系统性能的重要指标;而调度方式和调度算法由对处理机的利用率起着十分重要的作用。如果单纯提高处理机效率,那么应选择计算量大的作业运行。

    分时系统的目标

    1. 响应时间快。响应时间快是分时系统中调度算法的重要准则,所谓响应时间由三部分组成:命令输入时间、CPU处理时间、命令结果返回时间;
    2. 均衡性。不同的用户对响应时间的要求不同,简单任务要求较短的响应时间,复杂的任务允许较长的响应时间,均衡性是指,系统的响应时间应该和用户所请求任务的复杂度相适应;

    实时系统的目标

    1. 对截止时间的保证。对实时系统而言,调度算法的一个主要目标就是保证实时任务对截止时间的要求;其中对HRT任务,需要调度方式和调度算法必须确保对截止时间的要求;对SRT任务,要求调度方式和调度算法基本可以保证对截止时间的要求;
    2. 可预测性。在实时系统中,可预测性十分重要,主要是通过可预测性提高系统的实时性;

    作业调度

    作业是比程序更加广泛的概念,其中包括程序、数据和作业说明书,系统根据作业说明书来对程序的运行进行控制;

    作业控制块(JCB)

    1. 引入作业控制块的目的:管理和调度作业,系统为每个作业设置一个作业控制块JCB,它是作业在系统中存在的标记;
    2. 作业控制块的内容:它保存了系统对作业进行管理和调度所需要的全部信息。这些内容有:作业标记、用户名称、用户账号、作业类型(CPU型繁忙型、IO型、批量型、终端型)、作业状态、调度信息(优先级、作业运行时间)、资源需求(预计运行时间、内存大小等)、资源的使用状况等;

    作业运行的三种状态

    1. 收容状态。操作员将作业输入到硬盘上,为其建立JCB,将其放入作业后备队列中,等待调度,此时的状态称为收容状态;此时作业在外存上;
    2. 运行状态。作业被调度算法选中,为其分配了所需要的资源并建立了进程,将其进程插入到就绪队列中。从作业第一次进入就绪队列开始到作业完成,作业均处于运行状态;
    3. 完成状态。当作业完成、或者发生异常情况而提前结束时,作业将进入完成状态,系统中的相应程序将回收分配的资源和JCB,并将作业运行的结果输出;

    作业调度的主要任务

    作业调度的主要任务就是根据JCB中的内容,检查系统资源情况是否满足作业的要求,并按照一定的调度算法,从外存的后备队列中选择某些作业调入内存,为它们创建进程、分配资源,然后将进程插入到就绪队列中等待调度;其实归根到底需要解决两个问题:

    1. 接纳多少个作业

      这是由系统的多道程序度(Degree of Multiprogramming)决定的,即允许多少个作业同时出现在内存中;对系统而言,当然希望装入较多的作业以提高CPU的利用率和系统的吞吐量,但是内存中的作业过于多时,由于内存不够而引发的中断就会急剧增加,从而影响系统效率和服务质量;因此,多道程序度是由计算机系统的规模、运行速度、作业大小、以及能否获得较好的系统性能等确定的;

    2. 接纳那些作业

      最简单的调度算法是先到先服务算法;较常见的一中调度算法是短作业优先算法;另一种常见的算法是基于作业优先级的调度算法;比较好的调度算法是响应比高者优先算法;

    值得注意的是,作业调度只有在多道批处理系统中才有;因为分时系统因为要保证较高的响应性,所以用户输入的命令和数据被直接送入内存;所以分时系统中需要考虑的是如何控制用户的数量,无需考虑长程调度问题。实时系统也是类似;

    先来先服务算法(FCFS,First-Come First-Served)

    FCFS调度算法中,优先选择先到的作业或者进程进行服务,或者说,它选择的是在队列中等待时间最长的作业或者进程,而没有考虑作业自身的情况,比如作业的优先级、作业的预计运行时间等;基本上FCFS算法很少作为系统的主调度算法,但经常把它和其他调度算法相结合使用。

    该调度算法既可以用于作业调度也可以用于进程调度(即适用于长程调度和短程调度);

    短作业优先调度算法(SJF,Short-Job First)

    短作业优先算法使用作业或者进程的长短来标记它们的优先级,越短的作业(进程)其优先级越高;

    短作业优先调度算法相比先来先服务算法有了明显的感改进(考虑了作业或者进程自身的相关信息),但是仍然有缺点:

    1. 必须预知作业的运行时间,这不是很容易做到,如果估计偏低,那么系统可能会提前终止作业,而作业此时尚未完成;所以一般都偏长估计;
    2. 对长作业非常不利,一个极端的现象就是长作业根本得不到运行,即系统中总是有比该作业更短的作业,从而出现饥饿现象;即便在普通情况下,长作业的周转周期也会明显增长;
    3. 无法实现人机交互(需要交互的程序得不到运行);
    4. 没有考虑作业的紧急程度,不能保证紧迫的作业得到及时的处理;

    该调度算法既可以用于作业调度也可以用于进程调度;

    优先级调度算法(PSA,Priority-Scheduling Algorithm)

    优先级调度算法中选择作业或者进程的标准是它们的优先级,优先级越高,越早获得调度而执行;其实FCFS中,作业或者进程的等待时间就相当于其优先级;SJF中,作业的长度就相当于其优先级;但是这种优先级并不能反映作业或者进程的紧急程度;PSA算法就是要保证紧迫性任务得到优先运行;

    该调度算法既可以用于作业调度也可以用于进程调度;

    高响应比优先调度算法(HRRN,Highest Response Radio Next)

    FCFS算法中,只考虑作业或者进程等待的时间;SJF算法中,只考虑了作业或者进程的运行时间;高响应比优先调度算法既考虑了等待时间也考虑了作业或者进程的要求时间;是一种动态优先级设定;其优先权计算公式:优先权=(要求服务的时间+等待时间)/要求服务的时间;这样,当两个作业或者进程等待了相同时间时,短作业将获的较大的优先级,类似SJF调度方式;当两个进程要求服务时间相同时,等待时间长的作业将获得较大的优先级,类似于FCFS调度方法;这种调度方法的问题就在于每次进行调度时需要进行响应比的计算,于是会增加一定的系统开销;

    进程调度

    进程调度的任务

    进程调度的主要任务有三:

    1. 保留处理机线程。将当前进程的处理机现场记录到PCB中,包括程序计数器、多个通用寄存器的内容;
    2. 按照某种算法选择下一个执行的进程。调度程序将从就绪队列中选择一个进程,改变其运行状态,将处理机分配给它;
    3. 将处理机分配给进程。由分派程序将处理机分配给该进程,此时需要将对应的PCB中的内容装入相应的寄存器内,让其从上一次中断的地方开始执行;

    进程调度机制

    为实现进程调度,进程调度机制中,应具有以下三个部分:排队器、分派器和上下文切换器;

    1. 排队器的主要任务是将就绪状态的进程组织为一个或多个队列,以便调度程序可以可以快速找到它;每当一个进程转入就绪状态,排队器就把它插入到相应的就绪队列;
    2. 分派器的主要任务是将调度程序所选择的进程从就绪队列中取出来,然后进行从分派器到新进程的上下文切换;
    3. 上下文切换器的主要任务是,在发生进程切换时,首先将当前进程的相关信息存储到对应的PCB中,然后装入分派程序;然后将分派程序的上下文移出,装入新进程的处理机信息;即一次进程切换中,发生了两次处理机上下文的切换;

    由于一次上下文切换中需要执行大量的load和store命令,所以比较费时,现代系统以实现靠硬件来减少上下文切换时间;当然也可以采用两组寄存器,其中一组寄存器供处理机在系统态时使用,另一组寄存器供应用程序使用。这样只需改变指针即可实现上下文的切换;

    进程调度的方式

    早期系统大多采用非抢占式调度方式,但是这很难满足交互性作业和实时任务的需求,后来在进程调度方式中又引入了抢占式调度方式;

    1. 非抢占式调度

      非抢占式调度方式中,一旦把处理机分配给某个进程,就让它一直运行下去,绝不会因为时钟中断或其他原因而抢占当前正在运行进程的处理机,直到该进程完成或者因某事件而阻塞,才将处理机分配给其他进程;非抢占方式中,引起进程调度的原因有:

      1. 正在执行的进程正常结束,或者因为某事件而无法继续执行;
      2. 正在执行的进程提出IO请求而暂停执行;
      3. 在进程同步和通信中,执行了某种原语操作,如挂起原语等;

      这种调度方法的特点是系统开销小,简单,适合大多数批处理系统,但是不能用于分时系统和实时系统;

    2. 抢占式调度

      抢占式调度中,允许调度程序按照某种原则,暂停某个正在执行的进程;将已分配给该进程的处理机分配给另一进程;现代OS中广泛采用抢占式调度,这是因为,抢占式调度方法可以防止一个长进程长时间占用CPU,以确保处理机能为各个进程提供更为公平的服务,另外在分时系统中,只有抢占式调度才能实现人-机交互。实时系统中,抢占式可以满足实时任务的要求。但是抢占式实现起来比较复杂,系统开销较大;

      抢占不是一种任意的行为,它必须遵守一定的规则:

      1. 优先权原则:只有优先级高的进程才能抢占优先级低的进程的处理机,反之不行;
      2. 短进程优先原则:当新来进程所要求的服务时间明显少于当前执行进程还需要执行的时间时,发生抢占;
      3. 时间片原则:各进程按时间片轮转执行时,当正在执行的进程的一个时间片用完后,便停止该进程的执行;

    进程调度算法

    1. 轮转调度算法(RR,Round Robin)

      分时系统中最简单也是最常用的算法;该方式采用非常公平的处理机分配方法,即采用FCFS策略组织就绪队列,让就绪队列中的每一个进程每次都运行一个时间片;这种方法中,进程的切换发生在:

      1. 若时间片尚未用完,正在执行的进程便已完成,就立即激活调度程序;将其从就绪队列中删除,从就绪队列中选择队首进程运行,同时启动一个新的时间片;
      2. 若时间片用完,计时器中断处理程序被激活;如果进程尚未运行完毕,就把它送入就绪队列的末尾,重新排队;

      时间片大小的选取对系统性能有着很大的影响;若选择小的时间片,那么短作业则可能在一次时间片中就结束运行,但是时间片过小,那么系统将频繁发生进程调度和处理机上下文切换,增加系统开销;反之,若时间片太长,则RR退化为FCFS,无法满足短作业和交互式作业的需求;一个可取的策略就是时间片大小应略大一一次交互所需要的时间,这样使大多数交互式作业可以在一个时间片里完成,从而获得较小的响应时间;

    2. 优先级调度算法

      优先级调度算法中,将处理机分配给就绪队列中优先级最高的进程。按照是否允许抢占,分为抢占式和非抢占式;

      1. 非抢占式优先级调度算法

        该算法中,一旦将处理机分配给就绪队列中优先级最高的进城后,该进程便一直执行下去,直到结束(正常结束或者被阻塞、挂起等)才将处理机分配给就绪队列中另一优先级最高的进程;

      2. 抢占式优先级调度算法

        该算法中,把处理机分配给优先级最高的进程,使之执行,但是如果在其执行期间出现优先级更高的进程,调度程序就将处理机分配给新的优先级最高的进程;抢占式优先级调度算法常用于对实时性要求较高的系统中;

      优先级的类型——静态优先级和动态优先级:

      1. 静态优先级在创建进程的时候就已经设定,其运行周期内不再改变;常使用0-255中的一个整数来表示其优先级大小;设定静态优先级时需要考虑进程的类型,通常系统进程的优先级高于用户进程的优先级;进程对于资源的需求量,一般来说,需求量小的具有较高的优先级;用户的要求;静态优先级实现较为简单,系统开销小,但是不够精确,可能出现优先级低的进程长时间得不到运行的情况;
      2. 动态优先级是指进程的优先级会随着其运行发生改变,常见的需要考虑的变量有进程的初始优先级和等待时间等;
    3. 多队列调度算法

      多列调度算法中,将就绪队列组织为多个按照不同调度算法调度的就绪队列,以满足不同用户对调度策略的不同要求,并且这些就绪队列本身也可以设定优先级,方便在多处理机系统中为每个处理机设置一个单独的就绪队列;避免了仅有一个就绪队列时调度算法的固定、单一。这样对于含有多个线程的进程,可以将这些线程分配在一个就绪队列中,全部在一个处理机上运行;对于一组需要相互合作的进程而言,可以将其安排在一组处理机所对应的多个就绪队列中,使它们可以同时获得处理机并发执行;

    4. 多级反馈队列调度算法(Multileved feedback queue)

      前面介绍的进程调度算法,或多或少都有一定的局限性,如果未能指明进程的长度,则短进程优先和基于进程长度的抢占式调度算法都将无法使用。多级反馈队列不用提前知道各种进程的执行时间,还可以较好地满足各种类型进程的需要,是目前公认的一种较好地进程调度算法;它的核心为

      1. 设置多个就绪队列;系统中设置多个就绪队列,并且每个就绪队列也有自己的优先级。第一个队列的优先级最高,以此降低;该算法为每个队列中的进程所分配的时间片大小也是不同的,优先级越高的队列,其所分配的时间片越小(便于进程向低优先级转移);
      2. 每个队列都采用FCFS算法。当新进程进入内存时,将其放入第一队列的末尾,然后按照FCFS等待调度;如果该进程在时间片内完成,便撤离系统;否则进入第二队列末尾等待调度;当进程进入最后一个队列时,便采用RR方式运行;
      3. 按照队列优先级调度。调度程序首先调度最高优先级队列中的进程运行,仅当第一队列空闲时才调度第二队列中的进程;如果处理机正在第x队列中为某进程服务时,有新进程进入任意优先级较高的队列,那么该进程立即被送回第x队列末尾,将处理机交给新到的高优先级进程;

      多级反馈队列中,可以使短作业较早的完成,而且长作业经过第1,2,3…队列的执行,到最后一个队列时,采用RR调度算法,也不用担心过其作业长期得不到处理;

    5. 基于公平原则调度算法

      以上几种调度算法,保证了优先运行,但是并不能保证作业占用多少处理时间。另外也没有考虑调度的公平性;这里有两种相对公平的调度算法

      1. 保证调度算法,它向用户所做出的保证不是优先运行而是明确的性能保证,一种比较容易实现的性能保证算法是处理机分配的公平。如果系统中有n个进程,那么需要保证每个进程都获得相同的处理机时间1/n;实施公平调度算法时,系统需要:

        1. 跟踪计算每个进程自创建以来已执行的时间;
        2. 计算每个进程应该获得的处理机时间;
        3. 计算进程获得处理机时间的比率;
        4. 比较各个进程的这个比率,然后选择最小的进程,将处理机分配给它,并让该进程一直运行下去,直到超过最接近它的进程比率为止;
      2. 公平分享调度算法

        公平的角度不同,所使用的算法也就不同;保证调度算法对进程是公平的,但是对用户就不一定:有的用户拥有的进程多,有的用户拥有的进程少。公平分享算法是用户层面的公平调度算法。

    实时调度

    实时系统中存在两类不同的任务:硬实时任务和软实时任务;它们都关联着一个截止时间;实时调度算法必须能够满足实时任务对截止时间的要求;所以实时调度算法有一定的条件。

    实现实时调度的基本条件

    1. 提供必要的信息:系统应向调度程序提供有关任务的信息
      1. 就绪时间:某项任务进入就绪队列的时间;
      2. 开始截止时间和完成截止时间;
      3. 处理时间,从开始执行到结束需要的时间;
      4. 优先级,如果某项任务开始截止时间的错过将势必引起故障,那么将赋予该任务绝对的优先级;如果其开始截止时间的错过,对任务的继续运行没有重大影响,那么可以赋予该任务相对的优先级;
      5. 资源要求;
    2. 系统的处理能力强。如果系统的处理能力不够,那么很有可能因处理机忙不过来而导致一些实时任务得不到执行;提高系统处理能力有两种途径:一是使用单处理机系统,但是需增强其处理能力,以显著降低对每一个任务的处理时间;二是采用多处理机系统。
    3. 采用抢占式调度机制。广泛采用抢占式机制,可以满足HRT任务对截止时间的要求;但是这种调度机制实现比较复杂,对于一些小的实时系统,如果能预知任务的开始截止时间,则对实时任务的调度可以采用非抢占式调度机制,以降低调度程序和任务调度是所花费的系统开销;如果采用非抢占式调度机制,应使每个实时任务都比较小,以便能及时将自己阻塞起来,以便释放处理机;
    4. 具有快速切换机制。一是对中断的快速响应能力,对紧迫的外部事件请求中断能及时响应,要求系统具有快速硬件中断机制,还应使禁止中断的时间间隔尽量短,以避免耽误其他紧迫任务;二是快速的任务分派能力,为了提高分派程序进行任务切换的能力,应使系统中的每个运行功能单元适当的小,以减少任务切换的时间花销;

    实时调度算法的分类

    按照任务类型可以分为:硬实时任务调度算法和软实时任务调度算法;按照调度方式可以分为:抢占式调度算法和非抢占式调度算法;

    1. 非抢占式调度算法
      1. 非抢占式轮转调度算法:将实时任务组织为一个轮转队列,调度程序每次选择队列中的第一个任务投入运行,当该任务运行完毕后即将其放入轮转队列末尾等待。这种调度算法可以获得数秒到数十秒的响应时间,可用于不太严格的实时控制系统;
      2. 非抢占式优先调度算法:即使用优先权组织轮转队列;这种调度算法经过精心处理后,可以获得数秒到数百毫秒的响应时间,可用于有一定要求的实时控制系统;
    2. 抢占式调度算法
      1. 基于时钟中断的抢占式调度算法。在某实时任务到达时,如果它的优先级高于当前任务的优先级,这是并不立即抢占当前任务的处理机,而是等待时钟中断发生时,调度程序才剥夺当前任务的执行;这种算法可以获得较好的响应效果,其调度延迟可以降低到几十到几毫秒,可用于大多数实时任务系统中;
      2. 立即抢占的优先级调度算法。在这种调度策略中,要求操作系统有较高的快速响应外部事件中断的能力;一旦出现外部中断,只要当前任务没有处于临界区便立即剥夺当前任务的执行。这种调度算法可以获得非常快的响应,可把调度延迟减低到几毫秒到几百微秒;

    最早截止时间优先算法(Earliest Deadline First)

    该调度算法中,根据任务的截止时间确定任务的优先级,任务截止时间越早,优先级越大;具有最早截止时间的任务排在队列队首;调度程序选择任务时,直接选择就绪队列中的第一个即可;按照非抢占式和抢占式可以分为:抢占式最早截止时间优先和非抢占式最早截止时间优先这两种。非抢占式算法是指在某个任务执行的过程中,如果新到的任务的截止时间早于正在执行的任务的截止时间,并不会发生抢占;而抢占式则相反,会立即将处理机分配给优先级大的任务;通常而言,非抢占式常用于非周期性任务;抢占式常用于周期性任务;

    最低松弛度优先算法(Least Laxity First)

    该调度算法中,根据任务的紧急程度来确定任务的优先级,越紧急的任务,其优先级越大;而越紧急也意味着它的松弛度越低;在该算法中,任务的松弛度由任务的完成截止时间减去任务要求的处理时间来确定;该算法通常用于可抢占方式中;一般来说,抢占发生在某一任务的最低松弛度为0的时候,即该任务不得不执行,而考虑到任务切换的时间,通常还会提前一点;所以调度发生的情况为:某一任务正常结束或者某一任务的最低松弛度变为0;

    优先级倒置现象及其解决方法

    由于进城之间存在两种约束(直接约束和间接约束),所以有可能出现具有高优先级的进程因低优先级的进程而阻塞的情况;这种情况被称为优先级倒置;比如,低优先级A首先获得了临界资源R(因为比它高级的进程还没到),然后有比它优先级高的进程B到来,A被剥夺处理机,但是临界资源并没有被释放,之后用于最高优先级的进程C到来,B被抢占处理机,而C由于请求临界资源R失败而阻塞(进入阻塞队列),之后B开始运行,结束后A再运行临界区代码,进程A释放临界资源R后,C才能执行。这样B进程比C进程优先级低,但是先得到处理;常见的解决方法有两种:一是当进程处于临界区的时候,不允许中断,这样A执行完毕后,因为C的优先级高,处于就绪队列的前面,所以C可以在B之前执行;但是当A的临界区非常长,则C还是要等待较长时间;另一种办法是建立在动态优先级继承基础上的,该方法规定,当优先级较高的进程要进入临界区,使用临界资源,如果有一个低优先级进程正在使用该资源,那么高优先级进城被阻塞,而低优先级进程将继承高优先级进程的优先级,直到低进程退出临界区;这样就可以避免低进程被中等进程阻塞而出现优先级倒置现象;

    展开全文
  • 了解操作系统处理机调度概念的基本概念,处理机调度程序的功能,常用的处理机调度算法。C或C++编程方法与语句格式,提前初步编好试验程序。 3、实验方式: 通过实验室的微机上机,实际调试程序。 4、实验环境: ...
  • 操作系统课件,处理机调度整理,考研专用资料。
  • 处理机调度 操作系统 计算机
  • 操作系统 处理机调度与死锁
  • 操作系统课设 处理机调度程序 实验报告和源码
  • 天津理工大学操作系统实验报告一 ,处理机调度
  • 操作系统程序设计处理机调度模拟,采用优先级调度算法,进程每运行一个时间片优先级降低一级,内存分配采用首次适应算法,基本实现了处理机调度中的挂起、解挂、就绪、运行、后备等功能。 程序采用C++/Qt完成。
  • 第六章 处理机调度 一 处理机多级...系统吞吐量大相同时间内完成作业 进程尽可能多 处理机调度通常可分为两级调度作业 调度与进程调度 操作系统类型不同处理机调度等级 也是不同 1批处理系统中处理机调度 2多任务操作系

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 168,947
精华内容 67,578
关键字:

操作系统处理机调度