操作系统

内容大纲
╭第一章操作系统简介
|第二章进程管理------进程调度算法及信号量机制
|第三章进程调度与死锁-银行家算法
操作系统<
|第四章内存管理-------基于分页存储管理方式及动态分区分配与回收算法;
|第五章文件管理-------求系统能管理的单个文件最大长度;
╰第六章设备管理-------磁盘调度算法;

2.操作系统的发展
1>发展阶段
╭ ╭*1.单道批处理系统内存中只有一道作业,可以自动成批处理作业;
| |
| |*2.CPU<--|作业1|空闲区|<---|作业2|作业3|作业4|
| | cpu 内存外存(磁盘,U盘等)
| |
| | ╭自动性:单道批处理系统使计算机能在操作系统控制下,自动地将作业从外存装入内存运行;
|1> 单道 < *3.特点< 顺序性:存放在外存中的作业按顺序依次被装入内存,先进入内存的作业,先运行完毕;
| 批处理系统 ╰单道性:任意时刻内存中只有一道作业;
| |
| | ╭优点:与无操作系统的计算机系统相比,减少了等待人工操作的时间;
| |*4.优缺点< 缺点:由于作业独占CPU和内存,当作业进行I/O时,CPU只能等待
| | ╰ I/O完成而无事可做,使得CPU资源不能得到充分利用;
| ╰
|
| ╭*1.用户提交的作业都先存放在外存中,并排成一个队列,该队列被称为"后备作业队列"
| | 由操作系统的作业调度程序按一定策略从后备作业队列中选择若干个作业调入内存,
| | 使它们共享CPU和系统中的各种资源;
| |
| | 3.调度性
| | ↗ ↖
| | 进程作业
| | 调度(单/多CPU系统) 调度(一/多个被装入内存的作业)
| |*2.CPU<----|作业1|作业2|作业3|<---|作业4|作业5|作业6|
| | cpu 内存外存(磁盘,U盘等)
|2> 多道 < ↙ ↘
| 批处理系统作业1先进入内存内存中可以同时功能和实现技术都比
| | 但可能作业2先完成驻留多道程序单道批处理系统复杂的多
| | 2.无序性 1.多道性 4.复杂性
| |
| |*3.特点-->多道性,无序性,调度性,复杂性; (选择,填空)
| |
| | ╭优点:能够提高CPU,内存和IO设备的利用率和系统的吞吐量;
| |*4.优缺点<
| ╰ ╰缺点:系统平均周转时间长,缺乏交互能力;;
|
发展<
| ╭*1.允许多个用户通过终端机同时使用计算机,使终端用户感觉自己独占计算机资源,
| | 并且实现用户与主机的及时交互;
| |
| |*2.结构示意图:
| | 用户请求响应及时<--主机--> 用户可以通过终端与系统进行广泛的人机对话-->4.交互性
|3> 分时 < 3.及时性 / | \
| 操作系统分机1 分机2 分机3-->允许一台主机上同时连接多台联机终端-->1.多路性
| | 各终端用户彼此独立操作互不干扰-->2.独立性
| |
| |*3.特点-->多路性,独立性,及时性,交互性; (选择,填空)
| |
| ╰*4.优点:提高了终端与主机的响应速度,也提高了操作系统的交互性;
|
| ╭*1.实施系统必须及时响应外部事件的请求,在规定时间内完成对该事件的处理,
| | 支持实时计算,主要用于实时控制和实时信息处理领域,
| | 目标是快速响应且比分时有更高的可靠性;
| |
| |*2.结构示意图:
|4> 实时 < 用户请求响应能在<--主机-->由于应用领域的特殊性对可靠性要求很高-->5.可靠性
| 操作系统规定时间内处理 / | \-->用户可以通过终端与系统进行广泛的人机对话-->4.交互性
| | 3.及时性分机1 分机2 分机3 -->允许一台主机上同时连接多台联机终端-->1.多路性
| | 各终端用户彼此独立操作互不干扰-->2.独立性
| |
| |*3.特点-->多路性,独立性,及时性,交互性,可靠性(最重要)(选择,填空)
| ╰*4.实时信息处理系统的交互性仅限用于访问系统某些特定的专用服务程序;
|
|总结:批处理系统,分时系统和实时系统是三种基本的操作系统类型,
╰ 而一个实际的操作系统可能兼有三者或其中两者的功能特点;

2>操作系统的现状(选择题)
╭*1.主机操作系统: 是运行在大型主机上的操作系统,主要提供三类服务:批处理, 事务处理和分时处理;
|
|*2.服务器操作系统:是运行在网络服务器上的操做系统,可以通过网络同时为多个用户服务,允许共享硬件和
| 软件资源,服务器可提供打印服务, 文件服务,和web服务;
特征 <
|*3.微机操作系统:也称个人机操作系统,现代微机操作系统都支持多道程序处理,就是通常所说的支持多任务,
| 微机操作系统为单个用户提供良好的应用环境和应用软件开发环境;
|
╰*4.嵌入式操作系统:特征是小巧,实时性,可卸载,代码固化,弱交互性,强稳定性,接口统一,低能耗;

3.操作系统的特征
现代操作系统都支持多任务
╭*1.并发: 两个或多个事件在同一时间间隔内发生; (引入多道程序系统)几个程序在CPU上快速地轮流执行;
|*2.共享: 系统中的资源可供内存中多个并发执行的进程共同使用;资源共享有两种方式,即互斥共享和同时共享;
特征 < *3.虚拟: 虚拟是指通过某种技术把一个物理实体变成若干逻辑上的对应物,最常用内存虚拟化,
| 用户感觉到的内存大于实际内存; (只调用(读取)了应用程序的一部分资源进入内存) (将硬盘切分)
╰*4.异步性: 程序的运行结果,运行次序以及多次运行的时间都不确定;(进程以不可预知的速度向前推进)

5.操作系统的体系结构(了解)
1>系统元素的结构, 2>元素间的相互关系, 3>指导元素集成的模式和约束;
╭*1.简单的监控程序模型:功能简陋,任意时刻只能运行一个任务,保证了互斥访问,保护系统数据安全;
|*2.单体结构模型:所有的软件和数据结构都放在⼀个逻辑模块中,对外的⽤户程序提供⼀个完整的内核界⾯。
< *3.层次结构模型:将操作系统分解为多个⼩的、容易理解的层，系统功能被隔离在不同层中。
|*4.客户/服务器模型与微内核结构:核⼼功能外移,即把系统内核中的⼀些组成部分放作为独⽴的服务器进程来实现。
╰*5.动态可扩展结构模型:基本思想就是在运⾏过程中，能够动态地实现系统⾏为扩展的结构，也可称之为弹性结构。

6.指令的执行

2.进程的控制 (创建阻塞唤醒终止)

3.操作系统内核

4.进程同步

╭1.进程并发执行;
╭1>产生原因< 2.共享系统资源;
| ╰3.操作系统对共享过程进行控制和管理;
|
|2>同步机制: 保证在多任务共享系统资源的情况下,程序执行能得到正确的结果;
|
| ↗资源共享关系 ----> 保证各进程以互斥的方式访问临界资源 (保证数据执行的正确性)
|3> 多道程序环境下
| 进程之间的关系
| (进程同步任务) ↘相互合作关系 ----> 保证相互合作的各进程协调执行;
|
| ↗临界资源:必须以互斥的方式访问的共享资源称为临界资源;
|4> 临界资源和临界区
| ↘临界区:并发进程中访问临界资源的程序段 (代码段) 称为临界区;
|
| ╭ 进入区: 检查进程是否可以进入临界区; wait
|5> 同步机制的代码分布< 临界区: 并发进程中访问临界资源的代码段;
| ╰ 退出区: 释放临界区访问权;
|
|6>同步机制应遵循的准则:
|
| ╭1.空闲让进: 没有进程处于临界区,应允许一个请求进入临界区的进程进入;
| |
| |2.忙则等待: 临界区已有进程, 其他试图进入临界区的进程必须等待;
| 遵循准则<
| |3.有限等待: 对于要访问临界资源的进程,应保证有限时间内进入临界区;
| |
| ╰4.让权等待: 申请不到访问权,应释放处理机,以免浪费CPU资源;
|
|7>信号量机制:
| 定义:用信号量(某种类型的变量,如整型,记录) 的取值来表示资源的使用状况, 以此为基础实现进程同步;
| ╭1.整型信号量机制(*****)
| | *1.概念:是表示共享资源状态且只能由特殊的原子操作(原语) 改变的整型量;
| | *2.原理: 定义一个整型变量(Integer,int), 用该变量的值来标记资源的使用情况, 初值为1;
| | 整型信号量 >0 有资源可用; 整型信号量 <=0 资源忙,需等待; 实例:Linux中的自旋锁 SpinLock
| |
| | *3.使用整型信号量实现进程互斥的思想:
| | 为必须互斥访问的临界资源CS定义一个互斥信息量mutex(Integer),将初值设置为1,然后将CS放
| | 在wait(mutex)和signal(mutex)之间,当CS可访问时,wait(mutex)才能正常结束,使进程进入CS;
| |
| | *4.原语操作-->wait(s)和 signal(s) 执行不能被中断,具体实现如下:
| | var s :Integer;//定义一个整型变量 s, 表示资源
| | wait(s) { //用于申请资源
| | while(s<=0) do no-op; //整型信号量值<=0时无资源循环执行空操作(阻塞) no-option;
| | s=s-1; //如果 s<=0 一直走 while循环阻塞了不会走 s=s-1;
| | }
| |
| | signal(s) { //用于释放资源
| | s=s+1;//可用资源+1;
| | }
| |
| | *5.P1和P2两个进程都访问同一个临界资源 CS 定义一个互斥信号量 mutex, 将初始值置为1;
| | 在每个进程中将临界资源 CS 放入wait(mutex) 和 signal(mutex)之间;
| |
| | p1{ ... p2{ ...
| | wait(mutex) wait(mutex) //申请资源
| | CS CS ---临界资源 wait和signal 成对出现;
| | signal(mutex) signal(mutex) //释放资源
| | ...} ...}
| |
< |
| |2.记录型信号量机制
| | *1.原理: 定义一个记录型变量,用该变量的值来标记资源的使用情况;
| | *2.记录型信号量的数据类型:
| | Type semaphore =record
| | value : integer; //资源数量
| | L:list of process; //阻塞队列
| | end
| |
| | *3.记录型信号机制的原语操作 wait(s) ,signal(s)
| | s.value>=0时,s.value的值表示资源数量;--->进程继续执行
| | s.value<0时,s.value的绝对值表示等待队列中阻塞进程的数量;-->进程被阻塞
| | s.L; //阻塞队列
| | Var s: semaphore;//记录类型 semaphore 信号量
| | wait(s) { //用于申请资源
| | s.value=s.value-1; //如果s.value<1(右)则s.value<0(左);资源s.value ○ ○ ○
| | if s.value<0 then block(s.L);//加入阻塞队列阻塞队列s.L p1 p2 p3
| | }
| |
| | signal(s) { //用于释放资源
| | s.value=s.value+1; //s.value<=0-->s.value<=-1-->阻塞队列中至少有一个进程
| | if s.value <= 0 then wakeup(s.L); //唤醒一个在阻塞队列中的资源
| | }
| |
|信号量机制< *4.P1,P2和P3三个进程都访问同一个临界资源 CS 定义一个互斥信号量s,
| | s.value的初始值置为1,实现互斥的执行过程; s.value=1;//初始值
| |
| | p1{ ... ---> p2{ ... p3{... 等待队列
| | wait(s) wait(s) //申请资源 wait(s) P2
| | CS block block P3
| | //无可用资源 //阻塞队列有P2 //阻塞队列(p2,p3)
| | s.value=0; s.value= -1; s.value=-2;
| |
| | signal(s) CS CS 等待队列
| | wakeup(p2) signal(s) signal(s) 空
| | //阻塞队列剩p3 wakeup(p3) 结束
| | s.value=-1; s.value=0; s.value=1;
| | ...} ...} ...}
| |
| | *5.实现进程协调:
| |
| | /**示例1
| | * 爸爸擀饼, 妈妈烙饼,⾯板上只能容纳两张擀好的饼,只有当⾯板上有空闲空间时
| | * 爸爸才能把擀好的饼放在⾯板上, 只有当⾯板上有饼时，妈妈才能从⾯板上取饼,
| | * 试采⽤信号量机制实现爸爸和妈妈进程的同步。
| | */
| | Var empty, full: semaphore;//记录空区域和满区域
| | empty.value=2;//初始为2,面板上有两个空闲区域;
| | full.value=0; //没有饼
| | 爸爸进程如下{ 妈妈进程如下{
| | 擀饼; wait(full);//申请取饼;
| | wait(empty);//申请空位置取饼;
| | 放饼 signal(empty);//唤醒爸爸去擀饼
| | signal(full);//唤醒妈妈去取饼烙饼;
| | } }
| |
| | /**示例2
| | * 有两个进程pA,pB合作解决文件打印问题:pA将文件记录从磁盘读入主存的缓冲区,
| | * 每执行一次读一个记录,pB将缓冲区的内容打印出来,每执行一次打印一个记录,
| | * 缓冲区大小等于一个记录大小,使用记录信号量机制操作,确保文件正确打印
| | */
| | //为缓冲区设置互斥信号量mutex,设置资源信号量empty和full.3个信号量的初始值如下
| | var empty,mutex,full:semaphore;
| | mutex.value=1;//保证缓冲区只被一个进程使用,
| | empty.value=1; full.value=0;//记录资源状态;
| | pA{ pB{
| | 从文件中读一条记录; wait(full);申请满缓冲区
| | wait(empty);//申请空缓冲区 wait(mutex);申请互斥信号量
| | wait(mutex);//申请互斥信号量将数据从缓冲区读取出来
| | 将数据写入缓冲区 signal(mutex);//释放互斥信号量
| | signal(mutex);//释放互斥信号量 signal(empty);//释放空缓冲区
| | signal(full);//释放满缓冲区将取出的数据打印出来;
| | } }
| | *6.信号量机制的缺点:
| | 每个访问共享资源的进程都必须自备同步操作wait(s)和signal(s);
| |
| |3.AND型信号量机制(了解)
| | AND信号量机制基本思想是将进程在整个运行过程中所需要的所有资源一次性全部分配给进程,
| | 待该进程使用完成后再一起释放,只要还有一个资源不能分配给该进程,其他所有可能为之分配
| ╰ 的资源也不分配给它;(要么把它所请求的资源全部分配给进程，要么一个也不分配)
|
| ╭1.管程是描述共享资源的数据结构和在数据结构上的共享资源管理程序的集合;
| | *1.管程是可供程序员调用的软件包;
| | *2.每次只有一个进程调用管程执行;为了进行并发处理,管程必须包含同步工具;
|8>管程< *3.管程是一种编程语言的构建,所以编译器知道他们很特殊,并可以调用与其他过程不同的方法处理它们;
| |
| | ╭*1.变量的定义
╰ ╰包括< *2.变量的初始化代码, (管理进程) (p1/p2 | cs)
╰*3.以及管理共享资源的过程;

6.线程

第三章进程调度与死锁

╭功能:进程调度的功能由操作系统内核的进程调度程序完成,
| 在Linux内核中,进程调度的实现从调用内核函数schedule()开始;
╭1>进程调度程序 < 按某种策略和算法从就绪态进程中为当前空闲的CPU选择在其上运行的新进程;
| |
| ╰调度时机: 进程正常或异常结束,进程阻塞,有更高优先级进程到来,时间片完时;
|
| ╭*1.周转时间短: 作业从提交给系统开始,到作业完成,花费时间短; 结束时间-进入系统时间
| | 周转时间:作业在外存后备队列上等待调度的时间T1 +进程在就绪队列上等待进程调度的时间T2
| | +进程在CPU上的执行的时间T3 +进程等待I/O操作完成的时间T4;->T=T1+T2+T3+T4;
| |
| | 平均周转时间: T=(T1+T2+..+Tn)/n //求周转时间和带权周转时间时要画出相应表格;
| | 服务时间 Ts: 一个作业在CPU上执行的总时间; //CPU的占用时间;
| | 带权平均周转时间 W=(T1/T1s+T2/T2s+...+Tn/Tns)/n; //(T1周转/T1服务+...+Tn/Tns)/n
| | *计算机系统的设计者和管理者使用平均周转时间和带权平均周转时间来衡量系统的时间性能;
| | *切记:遇到保留2位小数,计算过程中除不净的都先保留3位小数,最后累加除以n时再保留2位小数;
| |
| |*2.响应时间快:从用户提交一个请求开始,到系统首次产生响应为止,花费时间短;
|2>调度算法准则< 1>从输入设备输入的请求信息传送到处理器的时间;↘
| | 2>处理机对请求信息进行处理的时间; (进程调度算法和输入/输出设备的速度都会影响响应时间)
| | 3>将所形成的响应信息回送到终端显示器的时间;
| |
| |*3.截止时间的保证: 保证作业在"开始截止时间"前开始, 在"完成截止时间" 前完成;
| | (评价实时系统性能的重要指标) 实时系统计算的正确性取决于计算的逻辑结果的正确性和计算时间;
| |
| |*4.系统吞吐量高: 系统在单位时间内完成的作业量多;
| |
| ╰*5.处理机利用率好:CPU的利用率高;
|
| ╭1.先来先服务调度算法(First-Come , First-Served, FCFS)(*****)
| | *1.定义:从就绪队列的队首选择最先到达就绪队列的进程,为该进程分配CPU;
| | *2.具体算法:
| | 题目给出上个进程结束题目给出开始+服务结束-开始
| | 进程名进入系统时间开始运行时间服务时间结束时间周转时间
| | P1 0 0 24 24 24
| | P2 1 24 3 27 26
| | P3 2 27 3 30 28
| |
| | 1) 求系统平均周转时间T: T=(T1+T2+..+Tn)/n---> (24+26+28)/3=26
| | 2) 求带权平均周转时间W: W=(T1/T1s+T2/T2s+...+Tn/Tns)/n;->(24/24+26/3+28/3)/3=6.33
| | *3.优缺点:
| | FCFS适合长进程,不利于短进程,FCFS有利于CPU繁忙进程,不利于I/O繁忙进程;
| |
| |2.短进程优先调度算法(Shortest-Process-First)(*****)
| | *1.定义:从就绪队列中选择估计运行时间最短的进程, 为该进程分配CPU;
| | *2.示例:
| | 题目给出上个进程结束题目给出开始+服务结束-开始
| | 进程名到达时间开始运行时间服务时间结束时间周转时间
| | A 0 0 34 34 34
| | B 1 38 7 45 44
| | C 2 45 15 60 58
| | D 3 34 4 38 35
| |
| | 解题思路:0时刻只有进程A,故先执行进程A,进程A完成后BCD也都相继进入了系统,
| | 再按短进程优先调度算法排列运行顺序: DBC,故最终执行顺序为ABDC;
| | 1) 求系统平均周转时间T: T=(T1+T2+..+Tn)/n---> (34+44+58+35)/4=171/4=42.75;
| | 2) 求带权平均周转时间W: W=(T1/T1s+...+Tn/Tns)/n;->(1+44/7+58/15+35/4)/3=4.98;
| | *在最早时刻内如果只有一个进程,就执行那个进程,当系统同时有多个进程则找服务时间最短的进程;
| |
| | *3.优缺点
| | 1)优点:与FCFS算法相比,短进程优先算法能有效降低进程的平均等待时间,提高系统吞吐量;
| | 2) ╭#1.对长进程不利;
| | 缺点< #2.不能保证紧迫进程的处理
| | ╰#3.进程长短由用户估计,不一定准确;
| |
| |3.优先权调度算法(*****)
| | *1.定义: 系统将CPU分配给就绪队列中优先权最高的进程;
| |
| | ╭1.非抢占式调度: 运行期间,有更高优先权的进程到来,也不能剥夺CPU;
| | *2类型<
| | ╰2.抢占式调度: 运行期间,有更高优先权的进程到来,就可以抢占CPU;
| |
| | ╭1.静态优先权:创建时确定,运行期间保持不变;(有可能导致饥饿状态)
| | *3优先权类型<
| | ╰2.动态优先权:创建时确定,随着进程推进或等待时间增加而改变;
| |
| | *4.静态优先权值通常可以根据进程的类型,进程需要的资源数量和用户的要求来设定;
| |
| | *5.缺点: 无穷阻塞(饥饿问题)-->解决方案:老化技术:增加等待时间很长的进程的优先权;
| |
| | *6.具体算法示例:
| | 有4个进程A,B,C,D,它们的到达时间,预计运行时间以及优先级数值(优先级数值越小,
| | 表示优先级越高) 如下表所示.(注:精确到小数点后2位);
| | 1)计算采用抢占式优先权调度算法的平均周转时间和平均带权周转时间;
| |
| | 已给已给已给结束-到达
| | 进程名到达时间开始运行时间预计运行时间优先数运行顺序结束时间周转时间
| | A 0 0 34 3 (第三) 1,4 56 56
| | B 1 1 7 1 (最高) 2 8 7
| | C 2 8 15 2 (次之) 3 23 21
| | D 3 56 4 4 (最低) 5 60 57
| |
| | 平均周转时间T: T=(T1+T2+..+Tn)/n---> (56+7+21+57)/4=141/4=35.25;
| | 带权平均周转时间W: W=(T1/T1s+T2/T2s+...+Tn/Tns)/n;->(56/34+7/7+21/15+57/4)/4
| | 周转时间/运行时间 =18.279/4=4.57;
| |
|2>进程调度算法<
| |
| | 2)计算采用非抢占式优先权调度算法的平均周转时间和平均带权周转时间;
| |
| | 已给已给已给结束-到达
| | 进程名到达时间开始运行时间预计运行时间优先数运行顺序结束时间周转时间
| | A 0 0 34 3 1 34 34
| | B 1 34 7 1 2 41 40
| | C 2 41 15 2 3 56 54
| | D 3 56 4 4 4 60 57
| |
| | 平均周转时间T: T=(T1+T2+..+Tn)/n---> (34+40+54+57)/4=141/4=46.25;
| | 带权平均周转时间W: W=( T1/T1s +T2/T2s+...+Tn/Tns)/n;->(34/34+40/7+54/15+57/4)/4
| | 周转/运行时间 =24.564/4=6.14;
| | 非抢占优先级调度顺序:
| | 进程执行根据到达时间及优先级的高低综合排序,未到达先执行已到达的,已到达的按优先级执行;
| |
| |4.时间片轮转调度算法(Round-Robin,RR)(了解)
| | *1.在分时系统中广泛应用,依赖于时间片大小(10-100ms);
| | 就绪队列 P1 P2 P3 P4
| | CPU的0.5s执行时间 |1-100ms|101-200ms|201-300ms|401-500ms|
| |
| | *2.定义:
| | 系统将所有就绪进程按先来先服务的原则,排成一个队列,每次调度时把CPU分给队首进程,并令
| | 其执行一个时间片,当时间片用完时,调度程序终止当前进程的执行,并将它送到就绪队列的队尾;
| |
| | *3.程序需要时间<时间片大小-->只需一个时间片,程序需要时间>时间片大小-->增加一个时间片
| | *4.时间片大小的确定:
| | T=Nq T:系统响应时间, N:进程数量, q:时间片;
| | *1.系统响应时间的要求: 响应时间要求越短,时间片越小;
| | *2.就绪队列中进程的数目: 进程数量越多,时间片越小
| | *3.系统的处理能力: 处理能力越好, 时间片越小;
| |
| |5.多级队列调度算法(了解)
| | *1.定义:将就绪队列分成多个独立队列,每个队列有自己的调度算法;
| | 优先级高队列: P1 P2 P3 P4
| | 优先级低队列: P5 P6 P7
| |
| |6.多级反馈队列调度算法(了解)
| | *1.定义:建立多个优先权不同的就绪队列,每个队列有大小不同的时间片;
| ╰ *2.特点: 队列优先权越高,时间片越短; 队列优先权越低,时间片越长;
|
|
| ╭1.实现实时调度的基本条件:(如下4个)
| | 1)提供必要的调度信息:就绪时间,开始截止时间,完成截止时间,处理时间,资源要求,优先级;
| | 2)系统处理能力强:
| | 假定系统中有m个周期性的实时进程,它们的处理时间可表示为Ci,周期时间表示为Pi,
| | 则在单处理机情况下,必须满足如下公式的限制条件:
| | /**
| | * m 实时进程个数
| | * ci 处理时间
| | * Pi 周期时间:
| | * i=1 (1<=i<=m) 表示从第1个实时进程开始处理,直到处理完第m个实时进程;
| | * ci/pi 处理时间(CPU分配)/周期时间(进程运行需要的时间)
| | * 如果单CPU满足:c1/p1+c2/p2+...+cm/pm <= 1 则能保证在截止时间内完成全部进程;
| | */
| | m ci C1 C2 Cm
| | Σ － <= 1 (1<=i<=m); // －+－ +...+－ <= 1 (截止时间内完成的限制条件)
| | i=1 Pi P1 P2 Pm
| |
| | 示例:
| | 在单处理机情况下,如果有6个实时进程,周期时间都是30ms,系统为每个进程分配
| | 6ms的处理时间,请问系统能否保证每个实时进程都能在截止时间内完成吗?为什么?
| |
| | 6/30+6/30+6/30+6/30+6/30+6/30=1.2>1;不能在截止时间内完成,因为不满足限制条件;
| |
| | 3)采用抢占式调度机制(广泛)
| | 抢占式调度算法根据抢占CPU的时机不同,可分为: 基于时钟中断的抢占和立即抢占;
| |
| | ╭1.对外部中断的快速响应能力:要求系统有快速的硬件中断机构,
| | 4)具有快速切换机制< 还应使禁止中断的时间间隔尽可能短;
| | ╰2.快速的进程切换能力:应使系统中的每个运行功能单位适当的小,
| | 以减少进程切换的时间开销
|3>实时系统中的调度<
| |2.常用的实时调度算法:
| | 1.最早截止时间优先算法(EDF)
| | 开始截止时间越早,进程优先级越高,越优先获得CPU;
| | *即可用于抢占式调度也可用于非抢占式调度;
| |
| | 2.最低松弛度优先算法(LLF)
| | /**
| | * 进程的紧迫程度
| | * T: 完成截止时间
| | * Tc:当前时间
| | * Ts:处理完该任务还需要的时间;
| | */
| | L=T-Tc-Ts; //进程的紧迫程度/松弛时间 L结果谁最小,先处理谁;
| | 淘宝 L1=12:40(截止优惠)-12:10(当前时间)-20(挑选+购买)=10分钟 (先处理)
| ╰ 京东 L2=12:30(截止优惠)-12:10(当前时间)-1(挑选+购买)=19分钟
|
| ╭1.当前正在执行的进程成为被替换进程,让出其所使用的CPU,以运行被进程调度程序选中的新进程;
| |2.具体切换步骤
| | *1.保存包括程序计数器和其他寄存器在内的 CPU上下文环境;
| | *2.更新被替换进程的进程控制块
|4>进程切换< *3.修改进程状态,把执行态改为就绪态或阻塞态;
| | *4.将被替换进程的进程控制块移到就绪队里或阻塞队列
| | *5.执行通过进程调度程序选择的新进程,并更新该进程的进程控制块;
| | *6.更新内存管理的数据结构
| ╰ *7.恢复被调度程序选中的进程的硬件的上下文;
<
| /紧密耦合:通过高速总线或高速交叉开关,实现多个
| ╭ / 处理器间的互连,共享主存系统和I/O设备,并要求将
| |*1.按耦合程度划分主存分为若干独立访问的存储器模块,以便同时对其访问;
| | \ 松弛耦合:有各自的存储器和I/O设备,通过通道或
| | \ 通信线路来实现多台计算机之间的互连;
| ╭1.多处理系统的类型<
| | | / 对称:处理单元功能和结构相同;(同构)
| | |*2.处理单元结构和功能是否相同分
| | ╰ \ 非对称:有多种类型的处理单元,功构不同;
| | 一个主处理器,多个从处理器;
| |
| | ╭1)静态分配:就绪队列的进程只能在与就绪
| | | 队列对应的处理器上运行;
| | | CPU1<-----cpu1就绪队列
| | | CPU2<-----cpu2就绪队列
| | ╭1.对称处理器系统中<
| | | |2)动态分配:进程随机被分配到当时处于
| | | | 空闲状态的某一处理器上执行
| | | |
| | | ╰ CPU1/CPU2<-------公共就绪队列;
| |2.多处理系统中进程分配方式<
| | | ╭主-从式的进程分配方式
| | | |(从机请求分配进程,主机分配调度进程;)
| | |2.非对称多处理器中<
| | | |优点:系统处理比较简单(同步及进程调度)
| | ╰ ╰缺点:有一台主机控制一切,存在不可靠性;
|5>多处理器调度<
| | ╭采用自调度的系统中设置一个互斥访问的公共的就绪队列,
| | ╭含义< 任何一个空闲的处理器都可自行从该就绪队列中选取一个
| | | ╰进程或一个线程运行;CPU1/CPU2<-公共就绪队列;(动态)
| | |
| | | ╭1.易移植:(最常用,最简单)
| | | | 易将单处理器环境下所用的调度机制移植到多处理器环境中;
| | ╭*1.自调度< 优点<
| | | | |2.有利于提高CPU利用率:
| | | | ╰ 不会出现处理器空闲或忙闲不均的情况;
| | | |
| | | | ╭1.瓶颈问题:处理器数量很多时;只能执行一个;
| | | | |2.低效性 :多次更换处理器,资源需要缓存;
| | | ╰缺点<
| | | |3.线程切换频繁:
| | | ╰ 某些线程因其合作的线程未获得,处理器而阻塞导致进程切换;
| ╰3.进程(线程)<
| 调度方式 | ╭含义:系统将⼀组相互合作的进程或线程,同时分配到⼀组
| | | 处理器上运⾏进程或线程与处理器一一对应;
| |*2.成组调度< cpu1读单词线程| 面向所有应用程序平均分配处理器时间;
| | | cpu2写单词线程| 面向所有的线程平均分配处理时间;
| | ╰优点:减少线程切换,减少调度开销;
| |
| | ╭1.在程序执行期间,专门为该程序分配一组处理器,每个线程
| | | 一个,这组处理器供该应用程序专用,直至应用程序完成;
| ╰*3.专用处理器分配<
| |2.优点: 加快程序运行速度, 避免进程或线程切换;
| ╰3.缺点: 处理器资源严重浪费;
|
| ╭1.定义:由于多个进程竞争共享资源而引起的进程不能向前推进的僵死状态称为死锁;
| | T1占R1,T2占R2,T1要R2,T2要R1
| |
| | ╭*1.产生原因:竞争共享资源且分配资源的顺序不当;
| | |
| | | ╭1.互斥条件 : 资源只能供一个进程用
| |2.死锁产生的 < |2.请求和保持条件: 每个进程不放弃请求互斥资源,且不放弃已有的资源
| |(原因和必要条件)*2.必要条件< 3.不剥夺条件: 不能剥夺其他进程的互斥资源
| | | |4.环路等待条件:在发生死锁时,必然存在一个进程申请资源的环形链;
| | ╰ ╰*只有四个条件同时满足时才会产生死锁
| |
╰4>死锁<
| ╭ 处理死锁方法: 预防,避免,检验,解除,忽略
| |
| |1.死锁的预防: 通过破坏死锁的产生条件,保证至少其中一个条件不成立来处理死锁(选择填空)
| |
| | 1)摒弃请求和保持条件:要求进程一次性申请需要的全部资源,申请其他资源前,释放已占资源
| | 2)摒弃不剥夺条件: 系统抢占被占用的资源分配给需要的进程;
| | 3)摒弃环路等待条件: 进程必须按规定的顺序申请资源;------按序分配算法预防死锁;
| |
| |2.死锁的避免:把系统的资源分配状态分为安全状态和不安全状态,
| | 只要资源分配使系统资源分配处于安全状态,死锁就不会发生;
| |
| | 系统有同类资源 m 个,被 n 个进程共享, 当m≤n时,
| | 每个进程最多可以申请多少个资源使系统不会发生死锁?并说明为什么.
| |
| | 设每个进程最多可申请x个资源,最坏的情况是: 在每个进程都占用了x个资源情况下,
| | 系统仍至少剩余一个资源,这样就能保证不发生死锁,即:
| | n(x-1) ≤ m; ==>x-1≤m/n==>因为 m≤n; 所以 x=1;
| |
| | ╭1.含义:能够找到一个进程执行序列,按照这个序列为每个进程分配资源,
| | | 就可以保证进程资源分配和执行顺利完成, 不会发生死锁;
| | | --通过资源的合理分配使系统处于安全状态,不可能发生死锁--;
| | |2.示例:
| | | 3个进程 P1, P2, P3 12个资源
| | 安全状态< 安全状态不安全状态
| | |进程最大需求已分配总体可用进程最大需求已分配总体可用
| | | p1 10 5 3 p1 10 5 2
| | | p2 4 2 p2 4 2
| | | p3 9 2 p3 9 3
| | ╰ 安全序列:<p2,p1,p3> 安全序列: 无
╰3.处理死锁 <
的基本方法 | ╭银行家算法 (Dijkstra 迪杰斯特拉)
| |是一种能够避免死锁的资源分配算法,其基本思想是一个进程提出资源请求后,
| |系统先进行资源试分配 ,然后检测本次的试分配,是否使系统处于安全状态,
| |若安全则按试分配方案分配资源,否则不分配资源;该算法需要数据结构的支持;
| |/**
| | * need[] 还需要的数量
| | * max[] 最大需求
| | * allocation[] 已分配的资源数量
| | */
| | need=max-allocation;
| |
| |
| |例1.
| |进程名称 allocation已分配 Max最大需求 Need还需要 Available可用
| | (A B C) 已知 (A B C)已知 (A B C) (A B C)已知
| | p0 0 1 0 7 5 3 7 4 3 3 3 2
| | p1 2 0 0 3 2 2 1 2 2
| | p2 3 0 2 9 0 2 6 0 0
| | p3 2 1 1 2 2 2 0 1 1
| | p4 0 0 2 4 3 3 4 3 1
| |
| | //1.对work和finish初始化->false为没执行 true为已执行
| | work=available=(3,2,2);//work -> A,B,C各可用资源数
| | finish[0]=finish[1]=finish[2]=finish[3]=finish[4]=false;
| |
| | 循环顺序检验是否能找到一个进程pi,满足finish[i]且needi<=work;
| |
| | 因为 finish[1]=false 且 need1<work->finish1=true, 可释放
| | allocation1->work=work+allocation1=(3,3,2)+(2,0,0)=(5,3,2);
| |
| | 因为 finish[3]=false 且 need3<work ->finish3=true, 可释放
| | allocation3->work=work+allocation3=(5,3,2)+(2,1,1)=(7,4,3);
| |
| | 因为 finish[4]=false 且 need4<work ->finish4=true, 可释放
| | allocation4->work=work+allocation4=(7,4,3)+(0,0,2)=(7,4,5);
| |
| | 因为 finish[0]=false 且 need0<work ->finish0=true, 可释放
| | allocation0->work=work+allocation0=(7,4,5)+(0,1,0)=(7,5,5);
| |
| | 因为 finish[2]=false 且 need2<work ->finish2=true, 可释放
| | allocation2->work=work+allocation2=(7,5,5)+(3,0,2)=(10,5,7);
| |
| | 所有进程finish[i]=true,故系统处于安全状态;序列:<p1,p3,p4,p0,p2>
| |
| 银行家算法<
| |例2.
| | 设系统中有三种类型的资源 A,B,C,资源数量分别为15,7,18,系统有五个
| | 进程P1,P2,P3,P4,P5,其中最大资源需求量分别为 (5,4,9),(4,3,5),
| | (3,0,5),(5,2,5),(4,2,4)。在T0时刻,系统为各进程已经分配的资源
| | 数量分别为(2,1,2),(3,0,2),(3,0,4),(2,0,4),(3,1,4),若采用银行
| | 家算法实施死锁避免策略,请解答下列问题:
| |
| |进程名称 allocation已分配 Max最大需求 Need还需要 Available可用
| | p1 (2,1,2) (5,4,9) (3,3,7) (2,5,2)
| | p2 (3,0,2) (4,3,5) (1,3,3)
| | p3 (3,0,4) (3,0,5) (0,0,1)
| | p4 (2,0,4) (5,2,5) (3,2,1)
| | p5 (3,1,4) (4,2,4) (1,1,0)
| |
| |1.画出T0时的资源分配状态表,并在表中显示进程还需要的资源数量和
| | 系统可用的资源数量;总A,B,C(15,7,18)-已用(13,2,16)=可用(2,5,2)
| |
| |2.T0时刻是否为安全状态?若是请给出安全序列;
| | //1.对work和finish初始化->false为没执行 true为已执行
| | work=available=(2,5,2);//work -> A,B,C各可用资源数
| | finish[0]=finish[1]=finish[2]=finish[3]=finish[4]=false;
| |
| | 循环顺序检验是否能找到一个进程pi,满足finish[i]且needi<=work;
| |
| | 因为 finish[3]=false 且 need3<work->finish3=true, 可释放
| | allocation3->work=work+allocation3=(2,5,2)+(3,0,4)=(5,5,6);
| |
| | 因为 finish[4]=false 且 need4<work->finish4=true, 可释放
| | allocation4->work=work+allocation4=(5,5,6)+(2,0,4)=(7,5,10);
| |
| | 因为 finish[5]=false 且 need5<work->finish5=true, 可释放
| | allocation5->work=work+allocation5=(7,5,10)+(3,1,4)=(10,6,14);
| |
| | 因为 finish[1]=false 且 need1<work->finish1=true, 可释放
| | allocation1->work=work+allocation1=(10,6,14)+(2,1,2)=(12,7,16);
| |
| | 因为 finish[2]=false 且 need2<work->finish2=true, 可释放
| | allocation2->work=work+allocation2=(12,7,16)+(3,0,2)=((15,7,18);
| |
| | 答案:(各加各的,对比每个资源所要个数)
| | 所有进程finish[i]=true,故处于安全状态;安全序列:<p3,p4,p5,p1,p2>
| |
| |3.在T0时刻若进程P1请求资源(3,0,3),是否能实施资源分配,为什么?
| | 不能,因为当前可用资源为(2,5,2)而请求资源为(3,0,3)可用资源不够分配
| |
| |4.在T0时刻若进程P4请求资源(2,0,1),是否能实施资源分配,为什么?
| |
| |进程名称 allocation已分配 Max最大需求 Need还需要 Available可用
| | p1 (2,1,2) (5,4,9) (3,3,7) (0,5,1)
| | p2 (3,0,2) (4,3,5) (1,3,3)
| | p3 (3,0,4) (3,0,5) (0,0,1)
| | p4 (4,0,5) (5,2,5) (1,2,1)
| | p5 (3,1,4) (4,2,4) (1,1,0)
| |
| | work4(4,5,6) p4, work5(7,6,10) p5, work1(9,7,12) p1
| | work2(12,7,14) p2, work3(15,7,18) p3 所以可实施资源分配,
| | 安全序列为:<p4,p5,p1,p2,p3>;
| ╰
|
| ╭ 检测当前系统是否出现死锁
| | 何时调用检测算法: 死锁可能发生的频率,死锁发生时受影响的进程数量;
| | 死锁定理:用于检测系统所处资源分配状态是否为死锁状态;
| | S为死锁状态的充分条件:是当且仅当S状态的资源分配图是不可完全简化的;
| | 完全简化:完全消除指向线,如下图p1请求2个资源,CPU分配2个,p1执行完
| | 释放资源,p2请求3个资源,p1释放后CPU就有3个资源,满足p2,故不死锁;
|3.死锁的检验<
| | 资源分配图 p1
| | 指向进程-->分配给进程 ↗ ↗ ↘
| | 进程发出-->进程请求 ○ ○ ○ ○
| | p+ 进程 ○ 资源 ○ ↖ ↙
| ╰ ↘ p2
|
| ╭检测到系统有死锁后进行解除;
| |
| | / 终止所有死锁进程;
╰4.死锁的解除< 进程终止
| \ 一次只终止一个处于死锁的进程,直到死锁解除;
|
╰资源抢占:逐步从进程中抢占资源给其他进程使用直到死锁被打破为止;

第四章内存的管理

╭0>内存管理的目标:实现内存分配和回收,提高内存空间的利用率和内存的访问速度;
|
| ╭1.存储器的层次结构: (层级高->低存储速度快->慢价钱贵->便宜)
| | *每一层级的存储器保存来自下一层级存储器的信息;
| | 寄存器(L0)/L1高速缓存/L2高速缓存/主存储器(L3)/本地二级存储(L4)/远程二级存储(L5)
| | \ (CPU内部少量) / 内存 ROM/RAM / 外存(辅助存储(长期)) (Web服务器)
|1>存储器的层次结构 <
| | ╭1)定义:在一段较短的时间内,程序的执行只限于某个部分,
| | | 相应的它所访问的存储空间也局限于某个区域;
| |2.局部性原理< /时间局部性:某条指令一旦执行,不久后该指令可能再次执行; (循环)
| | |2)分类
| ╰ ╰ \空间局部性:一旦程序访问了某个单元,不久后附近的存储单元也将被访问;
|
| ╭0.高级语言程序--编译-->目标模块--链接程序-->装入模块--装入程序-->内存可执行程序;
| |
| | ╭含义:将编译后的目标模块装配成一个可执行程序,分为静态链接和动态链接;
| | |1)静态链接:
| | | 程序运行前完成,用链接程序将目标模块链接成一个完整的装入模块;
| | | 静态链接程序任务:
| | | 1.对逻辑地址进行修改:(将逻辑地址-链接->连续的物理地址)
| | | 2.变换外部调用符号:将Call(调用语句)变为JSR(跳转子程序语句)
| | | 优点:运行速度快;
| |1.程序的链接<
| | |
|2>程序的链接和装入 < |2)动态链接:
| | | 可将某些目标模块的链接推迟到这些模块中的函数被调用执行时才进行;
| | | 优点:节省了内存和外存空间.方便了程序的开发;但浪费了一些时间;
| | | *对逻辑地址进行修改:
| | | 0 模块A L-1; 0 模块B M-1 -连接-> 0 模块1 L-1 L 模块2 M-1;
| | ╰ *变换外部调用符号:模块A CALL.B return-链接->模块A JSR L return;
| |
| | ╭1)绝对装入方式
| | | 编译时产生物理地址的目标代码,直接放入相应的物理地址位置
| | |
| | | *重定位:程序装入时对目标程序中的指令和数据地址的修改过程叫重定位;
| | |
| ╰2.程序的装入< 2)可重定位装入方式(静态重定位)
| | *1.编译时地址是逻辑地址,装入时通过重定位转换成物理地址;
| | *2.物理地址=逻辑地址+程序在内存中的起始地址;-->地址映射
| | 10000-15000 0-5000, 10000(物理内存起点)
| |
| |3)动态运行时装入(动态重定位)
| ╰ 程序执行时通过重定位转换为物理地址;
|
| ╭ 1.单一连续分区分配
| | ╭*1.内存只有一个用户区,任何时刻主存储器最多只有一个作业;
| | | |操作系统|一个作业 |空闲区| 单道批处理;
| | < 系统区 \ 用户区 /
| | |
| | ╰*2.该分配方式仅适用于单用户,单任务的系统;
| |
| | 2.固定分区分配
| | ╭将内存用户区划分成若干个固定大小的区域,每个区域中驻留一道程序;
| | |每个分区大小固定不变,每个分区仅可以装入一个作业(设有上下限)
| | |固定分区说明表:说明分区的起始地址,长度,是否占用的数据结构;
| | |
| | < 上限寄存器下限寄存器固定分区说明表(分区占用情况)
| | | ↑ L2 ↑ 分区编号分区大小分区起始地址分区状态
| | |0 a L1 b 当前作业 c L3 d 1 L1 a 空闲
| | ||操作系统|分区1| 分区2 |分区3| 2 L2 b 已分配
| | ╰ 系统区用户区 3 L3 c 空闲
| |
| | 3.动态分区分配
| | ╭*1.定义:系统动态地对内存进行划分,根据进程需要的空间大小分配内存;
| | |
| | |*2.特点:分区大小不是预先固定的,而是按作业的实际需求来划分的,
| | | 分区个数也不是预先固定的,而是由装入的作业数决定的;
| | |
| | < *3.优点:动态分区方式比固定分区方式显著的提高了内存利用率;
| | |
| | | 作业1(15k) 作业2(14k) 作业3(10k) 作业4(25k)
| | | 0 a b c d L1 e
| | | |操作系统|作业1(15k)|作业2(14k)|作业3(10k)|空闲区(20k)|
| | ╰ 系统区 \ 用户区 /
| |
| | 4.空闲分区表(分区空闲情况)
|3>连续分配存储管理方式 < 分区编号分区大小分区起始地址
| | 1 L1 d
| |
| | 5.空闲分区链:
| | ╭ 占用区 <--- 指向前一个空闲分区指针
| | | 100KB空闲区10KB --->▆-->▆-->指向后一个空闲分区指针
| | | 占用区 100KB:10KB u.size 进程申请的空间大小
| | < 130KB空闲区20KB 起始地址:空闲区大小 m.size 当前节点对应空闲区大小
| | | size 阈值定值
| | |
| | ╰ u.size<=m.size ?--Y-->m.size-u.size<=size?;
| |
| | ╭1)首次适应算法FF:(起始地址排序)
| | | 空闲分区链以地址递增的顺序链接,从链首开始查找,直到找到
| | | 第一个满足要求的空闲分区,从该分区中划出一块内存给进程,
| | | 剩下的仍留在空闲链中;留在链上为外部碎片,分配出去的为内部碎片
| | | 缺点:易产生外部碎片;
| | |
| | |2)循环首次适应算法NF:(起始地址排序)
| | | 从上次找到的空闲分区的下一个空闲分区开始查找;
| | | 若系统采用循环首次适应算法:->加一个循环指针;
| | | 优点:空闲区分布均匀;
| | |
| | |3)最佳适应算法BF:
| | | 空闲分区链以分区大小递增的顺序链接从链首开始查找,直到找到
| | | 第一个与进请求的空间大小最接近的空闲分区;
| | | 优点:提高内存利用率;
| | 6.动态分区 <
| | 分配算法示例:当前空闲链如下,若某进程p1先申请大小为30KB的内存空间,随后
| | | 进程p2再申请大小为20KB的内存空间,试画出给p1分配完之后的
| | | 空闲链和给p2分配完的空闲链;
| | | p1: 申请30KB
| | | ------->▅----------->▅---------->▅ p2: 申请20KB
| | | 20KB:120KB 200KB:100KB 400KB:60KB
| | |
| | |1)首次适应算法FF
| | | ------->▅----------->▅---------->▅ 分配完p1的30KB
| | | 50KB:90KB 200KB:100KB 400KB:60KB
| | |
| | | ------->▅----------->▅---------->▅ 分配完p2的20KB
| | | 70KB:70KB 200KB:100KB 400KB:60KB
| | |
| | |2)循环首次适应算法NF:
| | |
| | | ------->▅----------->▅---------->▅ 分配完p1的30KB
| | | 50KB:90KB 200KB:100KB 400KB:60KB
| | |
| | | ------->▅----------->▅---------->▅ 分配完p2的20KB
| | | 50KB:90KB 220KB:80KB 400KB:60KB
| | |
| | |3)最佳适应算法BF:(先按区间大小(长度)排序)
| | |
| | | ------->▅----------->▅---------->▅ 分配完p1的30KB
| | | 430KB:30KB 20KB:120KB 200KB:100KB
| | |
| | | ------->▅----------->▅---------->▅ 分配完p2的20KB
| | ╰ 450KB:10KB 20KB:120KB 200KB:100KB
| |
| | ╭1)释放一块连续的内存区域;
| | |2)如果被释放的区域与其他空闲区相邻,则合并空闲区;
| | |3)修改空闲分区链
| | |
| | |示例:当前空闲链如下图:
| ╰ 7.动态分区< ------->▅----------->▅---------->▅
| 回收流程 20KB:10KB 50KB:100KB 300KB:10KB
| |1.画出释放下列空闲区后的空闲链:
| |------->▅
| | 400KB:200KB (给定条件)
| |------->▅----------->▅---------->▅--------->▅
| | 20KB:10KB 50KB:100KB 300KB:10KB 400KB:200KB
| |
| |2.画出释放下列空闲区后的空闲链:
| | ------->▅
| | 30KB:20KB
| | --->▅------------->▅---------->▅--------->▅
| | 20KB:10KB(30KB) 50KB:100KB 300KB:10KB 400KB:200KB
| | --->▅------------>▅---------->▅--------->▅
| | 20KB:30KB(50KB) 50KB:100KB 300KB:10KB 400KB:200KB
| | --->▅---------->▅--------->▅ (合并空闲区)
| | 20KB:130KB 300KB:10KB 400KB:200KB
| |
| |3.画出释放下列空闲区后的空闲链:
| | ------->▅
| | 150KB:20KB
| | --->▅-------->▅----------------->▅--------->▅
| | 20KB:10KB 50KB:100KB(150KB) 300KB:10KB 400KB:200KB
| | --->▅-------->▅----------------->▅--------->▅
| ╰ 20KB:10KB 50KB:120KB 300KB:10KB 400KB:200KB
|
| ╭1.基本概念:
| | 1)页(PAGE):将一个进程的逻辑地址空间分成若干个大小相等的片,页是按物理单位划分的
| |
| | 2)页框(PAW FRAME): 将物理内存空间分成与页大小相同的若干个存储块;
| |
| | 3)分页存储:将进程中的若干页分别装入多个可以不相邻的页框中;(离散)
| |
| | 4)页内碎片:进程的最后一页一般装不满一个页框,形成页内碎片
| |
| | 5)页表(PAGE TABLE) : 实现从页号到页框号的映射;
| |
| | 页表
| | 用户程序页号块号内存
| | 0页 0 1 0 (2页)
| | 1页 1 3 1 (0页)
| | 2页 2 0 2 (3页)
| | 3页 3 2 3 (1页)
| |
| |2.分页地址结构: 逻辑地址的管理;
| | 2^m页 2^n字节(byte) A表示逻辑地址,L表示页大小一般是4KB
| | 占m位占n位 P=INT(A/L) INT表示取整
| | 页号p 页内偏移量w W=MOD(A/L) MOD表示取余
| | 20位 (页内地址)12位逻辑地址为十进制 5236,系统页大小为4KB,
| | 2^20页 2^12字节求该逻辑地址所在的页号P 和页内偏移地址 W;
| | ↓ ↓ P=INT(5236/4096)=1;(以byte为单位)(取整商)
| | 页的数量2^m(m位) 页的大小2^n(n位) W=MOD(5236/4096)=1140;(页内偏移量取余)
| |
| | 示例:考虑一个由8页,每页1k字节组成的逻辑地址空间,把它映射到由32个物理块组成
| | 的存储器,则逻辑地址有几位? 物理地址有几位? (页框的数量)
| | 2^m=8-> m=3位 2^n=1024-> n=10位; 页的大小==页框的大小=10位 2^m=32-> m=5;
| | 页号偏移量页框偏移量
| | | 3位 | 10位 |--->逻辑地址 13位 | 5位 | 10位 |--->物理地址 15位
| |
< 4>基于分页存储管理方式 <
| (离散分配存储管理方式) | ╭地址变换机构:↓
| | |1)进程执行,PCB中页表起始地址和页表长度给CPU的页表寄存器;
| | |
| | |2)确定CPU访问要访问的逻辑单元 A
| | |
| | |3)由分页地址变换硬件自动将A分为页号和页内偏移两部分;
| | |
| | |4)由硬件检索页表,得到A所在的页对应的页框号,
| |3.分页地址变换< 页号对应的页表项起始地址=页表起始地址+页表项长度+页号
| |(逻辑->物理地址) (页表项中存有页框号),从该地址指示的内存单元中读取页框号;
| | |
| | |5)页框号和页内偏移地址给物理地址寄存器,计算物理地址,
| | | 物理地址=页框大小*页框号+页内偏移量;
| | |示例:
| | |如图假定页大小为1KB,进程的逻辑地址空间有1026个单元,逻辑地址为
| | |0~1025,将逻辑地址空间划分为两个页,即0号页和1号页,请计算出逻辑
| | |单元1025 对应的物理地址;
| | |-----0 逻辑地址=1025
| | | 1kB | ↖ P=INT(1025/1024)=1-->页号为1;
| | |-----1023 ↖ 页表 w=MOD(1025/1024)=1-->页内偏移量
| | | 0 0 p=1--页表--> 页框号=2;
| | |-----1024 1 2 物理地址=页框大小*页框号+页内偏移量
| | | | ↙ =1024*2+1=2049;
| | ╰-----1025↙
| |
| | ╭1)一般为 512B~4KB;
| | |2)页的大小由机器的体系结构和操作系统共同决定的;
| |4.页大小的选择<
| | |3)选择因素:管理内存的开销,内存的利用率:
| | ╰较小,划分为较多页,页表过长,占内存较大,页内碎片大,空间利用率低;
| |
| | ╭1.定义:
| | | 快表也称"转换后援缓冲",是为了提高CPU访存速度而采用的专用缓存,用来
| | | 存放最近被访问过的页表项;(放到CPU的寄存器中) (局部性原理)
| | | 先找快表再找页表快表-->页号(键) 页框号(值)->最近被访问的页表项;
| | |
| | |2.先查询快表,如果在快表中没找到就去内存中的页表中查询;
| | |
| | |3.引入TLB之后的地址变换过程:
| | | *1.CPU产生分页的逻辑地址页号和页内偏移量后,将该逻辑地址的页号提交给TLB;
| | |
| | | *2.查找TLB,若找到页号,则把该页所在的页框号用于形成物理地址,否则(TLB失效)
| | | 查找内存页表,从内存页表中找相应的页表项,读取页所在的页框号,形成物理地址;
| |5.快表 <
| | (TLB) | *3.如果所查的页表项不再TLB中国,在访问完内存页表后,要把找到的页表中
| | | 的页号和页框号写到TLB中,若TLB的条目已满,系统会根据某种策略((如
| | | 最近最少使用替换)选择一个TLB中的条目,用刚访问的页表项信息,替换
| | | 选中的TLB条目;(新访问的存入快表)
| | |
| | |4.引入TLB的性能分析
| | | TLB命中率:在TLB中找到某个页号对应的页表项的百分比;
| | | #1.一次访问内存页表 #2.访问内存读写数据或指令;
| | | *1.当能在TLB中找到所需要的页表项时:
| | | 有效访存时间=一次访问TLB时间 + 一次访问内存时间(#2)
| | |
| | | *2.当没有在TLB中找到所需要的页表项时:
| | | 有效访存时间=一次访问TLB时间 + 两次访问内存时间(#1+#2)
| | |
| | | *3.综合结论:
| | | 有效访存时间=(一次访问TLB时间+一次访问内存时间)*命中率+
| | | (一次访问TLB时间+两次访问内存时间)*(1-命中率);
| | | 示例:
| | | 在采用快表的存储管理方式中,假定快表的命中率为85%,快表的访问时间为
| | | 30ns,访问内存的时间为210ns,求系统的有效存时间
| | ╰ 有效访存时间=(30+210)*0.85+(30+420)*0.15=204+67.5=271.5ns;
| |
| ╰6.两级和多级页表: 将页表再分页,形成两级或多级页表,将页表离散地存放在物理内存中;
|
| ╭1.虚拟存储器:
| | 是指具有请求调入功能和置换功能,能从逻辑上对内存容量进行扩充的一种存储器系统;
| | *1.请求调入:
| | 先将进程的一部分装入内存,其余的部分什么时候需要,什么时候请求系统装入;
| | *2.置换:
| | 如果请求调入时,没有足够的内存,则由操作系统选择一部分内存中的进程内容移到
| | 外存,以腾出空间把当前需要装入的内存调入;
| |
| | ╭*1.提高内存利用率;
| |2.虚拟存储技术的优点< *2.提高多道程序度;
| | (*****) ╰*3.把逻辑地址空间和物理地址空间分开(编程不受物理空间限制)
| |
| | ╭*1.离散性: 实现虚拟存储管理的基础;
| | |*2.多次性;
| |3.虚拟存储技术的特点<
| | (*****) |*3.对换性
| | ╰*4.虚拟性: 实现虚拟存储系统的最重要目标;
| |
| |请求分页系统是最基本 , 最常用的虚拟存储系统的实现方式;
| |
| |4.请求分页中的硬件支持:
| | ╭*需要:特殊的页表, 缺页异常机构和支持请求分页的地址变换机构;
| | |*1.特殊的页表: 页号页框号状态位P 访问字段A 修改位M 保护位
| | | 标识页记录页标识页标识页
| | | 是否在最近被最近是否的访问权
| | | 内存中访问的情况被修改过
|5>基于分页的虚拟存储系统< <
| (离散分配存储管理方式) | |*2.缺页异常机构:在访问内存过程中发现缺页时产生缺页异常信号;
| | |
| | |*3.请求分页的地址变换机构--->计算出页号和页内偏移地址:
| | | 如果查找的页尚未调入内存,则产生缺页异常,请求调入该页,修改页表,重新执行
| | | 因缺页被中断的指令(因为用的是虚拟存储,所以被查找的页号可能在外存)
| | ╰*查找快表-没找到->查找内存-没找到->产生缺页异常,将外存中的该页调入内存页表;
| |
| | ╭1)至少页框数: 保证进程正常运行所需的最少页框数;(与进程大小无关)
| | | 相关因素:与计算机硬件结构有关,取决于指令格式,功能和寻址方式;
| | |
| | |2)选择淘汰页--->局部置换和全局置换; 分配-->固定分配, 可变分配
| | | (自己进程中选) (全局选) (被分配的页框数是否固定)
| | | ╭*1.固定分配局部置换: 进程创建时就固定了被分配的页框数.自己选淘汰页;
| | | |
| |5.页分配策略< < *2.可变分配全局置换: 系统会再分配空闲页框,从所有进程中选择淘汰页;
| | | |
| | | ╰*3.可变分配局部置换: 系统会再分配空闲页框,从自己进程中选择淘汰页;
| | |
| | |3)分配页框算法:
| | |
| | | ╭*1.平均分配算法: 平均分配后,剩余的放入空闲页框缓冲池里;
| | | |
| | | < *2.按比例分配算法:
| | | |
| | ╰ ╰*3.考虑优先权的分配算法:
| |
| | ╭*1.最佳置换算法(ORA):主要用于理论研究:(以后永远不会被访问的页)
| | |*2.先进先出置换算法(FIFO):最简单的(调入最早换出)
| | |*3.最近最久未使用置换算法(LRU)(用一个字段记录一个页自上次被访问时间)
| | |*4.其他置换算法:简单Clock置换(选择最近没有被访问的),改进Clock,最少使用
| | |
| | |示例:
| | |假定系统为某进程分配了 3 个页框,并考虑有一下的页访问序列:
| | |7,0,1,2,0,3,0,4,2,3,0,3,2,1,2
| | |1)画出采用先进先出置换算法时的置换图:
| | | 队首最先进来,要被替换新调入的加入队尾,队首出队列
| | | 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2
| | || 7 | 7 | 7 | 0 | | 1 | 2 | 3 | 0 | 4 | 2 | | | 3 | 0 |页框1
| | || | 0 | 0 | 1 | | 2 | 3 | 0 | 4 | 2 | 3 | | | 0 | 1 |页框2
| | || | | 1 | 2 | | 3 | 0 | 4 | 2 | 3 | 0 | | | 1 | 2 |页框3
| | |缺页缺页缺页缺页缺页缺页缺页缺页缺页缺页缺页缺页
| | |中断中断中断中断中断中断中断中断中断中断中断中断
| | |缺页率=缺页/所要访问的页 12(缺页数)/15(访问总数), 页置换:9次
| |6.页置换算法<
| | |2)画出采用 LRU置换算法时的置换图:
| | | 用新调入的页替换最长时间没有访问的页面:看当前访问数离哪个页框中的数最远
| | | 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2
| | || 7 | 7 | 7 | 2 | | 2 | | 4 | 4 | 4 | 0 | | | 1 | |页框1
| | || | 0 | 0 | 0 | | 0 | | 0 | 0 | 3 | 3 | | | 3 | |页框2
| | || | | 1 | 1 | | 3 | | 3 | 2 | 2 | 2 | | | 2 | |页框3
| | |缺页缺页缺页缺页缺页缺页缺页缺页缺页缺页
| | |中断中断中断中断中断中断中断中断中断中断
| | |中断: 10次缺页率=10(缺页数)/15(访问总数), 页置换:7次
| | |
| | |3)缺页率对有效访问时间的影响
| | | P为缺页率:
| | | 有效访问时间=0.1+24999.9*P;
| | | 有效访问时间和缺页率成正比,缺页率越高,有效访问时间越长,访问效率越低
| | |
| | |4)工作集:
| | | 含义: 某段时间间隔里,进程实际访问的页的集合
| | ╰ 目的: 降低缺页率,提高访问内存效率;
| |
| | ╭含义:运行进程的大部分时间都用于页的换入换出,几乎不能完成任何有效工作的状态;
| | |
| | |产生原因:进程数量太多,每个进程分配页框太少,以至进程运行过程中频繁请求调页;
| ╰7.抖动<
| | ╭采取局部置换策略;
| |预防方法< 在CPU调度程序中引入工作集;
| ╰ ╰挂起若干进程;
|
|
| ╭*1.在分段存储管理的系统中,程序员使用二维的逻辑地址,
| | 一个数用于表示段,另一个数用来表示段内偏移;(段大小不定)
| | 页: 0号页 0~1023, 1号页 1024~2047 一维页+偏移量(页内地址)
| | 段: 0号段 0~1023, 1号段 0~1023 二维段号+偏移地址(段内地址)
| |
| |*2.引入分段机制的优点(实现实时信息共享)
| | 方便编程, 分段共享, 分段保护, 动态链接, 以及存储空间的动态增长;
| |
| |*3.分段的逻辑地址结构:
| | 1)进程的地址空间被划分为若干个段,每个段定义了一组逻辑信息,
| | 每个段的大小由相应的逻辑信息组的长度确定, 段的大小不一样,
| | 每个段的逻辑地址从0开始,采用一段连续的地址空间;
| |
| | 2)系统为每个段分配一个连续的物理内存区域,各个不同的段可以离散地
| | 放入物理内存不同的区域;
| |
| | 3)段表是由操作系统维护的用于支持分段存储管理地址映射的数据结构;
| | ↓
| | 4)系统为每个进程建立一张段表(地址映射),段表的每个记录信息包括段号
| | ,段长(段大小) 和该段的基址(段的物理起始地址),段表存在内存中;
| |
| ╭1.分段机制的引入 < 段表寄存器段号S 段内偏移 d
| | | 段表始址|段表长度 <-------段表------------ 2 100 有效地址
| | | ↓ 段号段长段基址(段的起始地址) ↓ 8*1024+100
| | | 段号为 0 300B 2KB ↓ =8192+100
| | | 段表索引 1 200B 4KB ↓ =8292 B
| | | ↓--映射-->2 150B 8KB------------->8192(物理地址)
| | | 3 100B 12KB ↓ 100<150 (合法)
| | | ↓ +100 段内偏移
| | | 1>段号s对应的物理地址=段号s的段基址+段内偏移w; 主存 8292 B
| | |
| | | 2>在分段系统的地址变换过程中，CPU上段表寄存器中存有当前在CPU上
| | | 运行进程的段表起始地址。用段号作段表的索引,根据段表起始地址和
| | | 段号可以获得段号s对应段表项的内存地址: (找到段表数据)
| | | 段号s对应的段表项的内存起始地址=段表起始地址+段号s*段表项长度。
| | |
| | |*4.分段系统的地址变换:
| | | 若已知逻辑单元的地址为s(段号):d(偏移量),求相应物理地址的步骤:
| | | 1)以段号为索引,从段表中找到段号为s的段表项;
| | | 2)从找到的段表项中读出s段的基地址和段大小;
| | ╰ 3)如果d<=段大小,则将段基址与段内偏移d相加,得到相应的物理单元地址
| |
| |
| | ╭分页和分段都属于离散分配方式,都通过数据结构与硬件配合实现逻辑到物理地址的映射;
| | |区别如下:
|6>分段存储管理 < 2.分页和分段< 1)页是按物理单位划分的,段是按逻辑单位划分的;
| (离散分配存储) 的主要区别 |2)页的大小是固定的,而段的大小不固定,取决于用户编写的程序和编译器;
| | ╰3)分页地址空间是一维的, 分段的地址空间是二维的;
| |
| | ╭1)将用户进程的逻辑空间先划分成若干个段, 每个段再划分为若干个页
| | |2)进程以页为单位在物理内存中离散存放,每个段中被存放的页具有逻辑相关性;
| | |3)为了实现地址映射,操作系统为每个进程建立一个段表,再为每个段建立一个页表;
| | |4)进程段表的每一个段表项存放某个段的页表起始地址和页表长度;
| | |
| | |5)地址变换过程如下:
| | |
| | | 段表寄存器段号S 页号P 页内偏移量W
| | | 段表始址|段表长度<---------段表-----------2 2 500k-
| | | ↓ ---------↓ ↓
| ╰3.段页式存储管理 < 映射段表 ↓ 页表 ↓
| | ↓ 段号状态页表大小页表始址 ↓ 页号状态页框号 ↓
| | ↓ 0 1 300k 200k ↓ 0 1(在内存) ↓
| | ↓ 1 0(不在内存) 800k ↓ 1 1 ↓
| | ↓----> 2 1 400k 1200k----> 2 0 5<--↓
| | ↓(物理地址)
| | 主存(页框大小*页框号+页内偏移量)
| | *地址变换步骤:
| | 1)以段号s作索引,找到段s的段表项,得到该段页表的起始地址;
| | 2)通过分页机制从段内偏移d中分离出页号P和页内偏移W;
| | 3)以段内页号P作为索引,从段s的页表中搜索页号P对应的页表项;
| | 4)从页表项得到页所在的页框号; 物理地址=页框大小*页框号+页内偏移量
| ╰ 5)由页框号与页内偏移W得到对应物理地址.↗
|
|
| ╭*1.伙伴云算法把所有的空闲页框分组为11个链表,每个块链表分别包含大小为:
| | 1,2,4,8,16,32,64,128,256,512和1024个连续的页框; 0~10链表--2^0~2^10--4KB~4MB
| |
| | ╭1.两个块具有相同的大小,记做b; (一组4KB)
╰7>LINUX的伙伴系统< *2.伙伴的满足条件<
(了解) ╰2.它们的物理地址是连续的.起始地址是 2b 的整数倍
|
╰*3.内核视图把大小为b的一对空闲伙伴合并为一个大小为2b的独立块;

第六章 I/O设备管理

posted @ 2023-11-28 16:57 R-Bear 阅读(40) 评论(0) 编辑收藏举报

刷新页面返回顶部

R-Bear

操作系统

公告