操作系统笔记——储存系统、文件系统(王道408)

文章目录

前言

属实是极限冲刺了,距离考研还有10天,我还有俩本书没学完(乐),昨天一下午一晚上学完进程,今天再接再厉,直接学完储存和文件系统

IO部分参见我的计组笔记,非常详细

储存系统

我不喜欢重复造轮子,这一章我会比较简略,尽量写高层次的思想,具体内容我的另一篇笔记里面记录的很详细,如果基础不是很好,可以对照看。

操作系统笔记------储存器管理、文件管理、设备管理

地址转换

关于物理地址:

  1. 逻辑地址:从源程序到汇编语言程序的这些阶段,都用逻辑地址
    • 逻辑地址默认0为地址起点,不考虑和其他程序之间的相互作用
    • 因此,后续几步,直到把程序装入内存的整个过程,肯定是要将逻辑地址变为物理地址的
  2. 后续的步骤为编译链接为目标模块,装入内存。如何变,就形成了3种不同的方法
    • 绝对装入(很low,没OS才这么做):在编译链接阶段形成物理地址
    • 静态重定位(可重定位装入):在装入的过程中,将指令内容修改,形成物理地址
    • 动态重定位(动态运行时装入):指令内容一直是逻辑地址,使用重定位寄存器辅助地址偏移,在程序真正运行访存的时候才形成物理地址

(才发现我们OS老师上课用的那张图是从王道这里来的,我就说风格怎么不一样)

我们前面讨论的是如何形成物理地址,其实形成如何把多个.o文件的逻辑地址统一起来,也是一个需要注意的点,这个技术就是链接

  1. 静态链接:链接阶段一次性组合
  2. 动态链接
    • 装入时动态链接:装入的时候,一次性组合
    • 运行时动态链接:调用的时候,才针对性的装入对应的模块(.dll动态链接库)

联系前面的物理地址生成,很显然,绝对装入方法只能搭配静态链接使用,而动态链接只能和重定位方法结合使用

视角抬高,内存管理除了负责部分地址转换以外,还有很多功能。

内存保护的两种思路:

  1. 上下限寄存器:直接记录程序物理地址的上下线
  2. 重定位寄存器+界地址寄存器:界地址寄存器规定了逻辑地址的上限

内存扩展

覆盖

覆盖,就是让互斥的程序段公用一片内存,有两种可能:

  1. 固定区:互斥程序段只有一个,那么这片区域就是独占
    • 一般来说,只有一个固定区(main函数)
  2. 覆盖区:有多个程序公用,每一个覆盖区都由当前覆盖段里占内存最大的模块决定。
    • 比如B先用内存,C要用,就把B的部分直接覆盖就行,这也是这个名字的来源

这个方法的缺点就是需要人为指定覆盖结构(计算机不会分析),不方便。

交换

交换就是把暂时不用的程序换出,腾出空间给其他程序运行。

结合第二章,交换其实就对应着中级调度

因此换出的程序首选被挂起的程序,其次就是低优先级的,总之尽可能减小换出的副作用。

交换区要频繁读写,因此单独划出。

为了加快读写,采用连续分配的方式管理磁盘(IO更快)

储存器分配------连续分配

所谓连续分配,就是程序要放就是一整段全放进去,不可以拆开。

固定大小分区

说白了,单一连续分配就是只有一个应用分区

因此没有外部碎片,只有内部碎片

下面的固定分区分配,其实就是把这一个区,拆分成多个固定的区,只分配,不改变大小。

既然思想一致,只是分区数量的差异,那么碎片的逻辑也就一样了。

多个分区还要进行管理,需要一个固定分区表,这个表能修改的只有分配标记

如果最大的那个分区都满足不了当前程序,就上覆盖技术。

动态分区分配

动态分区就是固定分区加强版,除了可以修改标记以外,还可以修改区域的大小。

数据结构有两种:

  1. 分区表
    • 沿用固定分区的思路
  2. 空闲分区链。这里注意一下其结构
    • 这是一个双向链表,有首尾两侧链域
    • 中间部分,可以存放分区的描述信息

分配和回收的过程中,要涉及到分区的拆分和回收合并:

  1. 拆分:动态分配算法
  2. 回收:会涉及到表项/节点的修改或者删除,要具体讨论

动态分区的思路,可以保证新分的区是满的,所以没有内部碎片

代价就是会产生外部碎片,内存中有一些地方因为太小是怎么也用不到的

解决方法也很直接,就是把分区挪一下,挤一挤,即紧凑技术。

很明显,程序在这个过程中浮动了,因此只能搭配 动态运行时装入(动态重定位)技术使用。

动态分区分配算法

  1. 首次适应
    • 遍历空闲分区表/链,第一个能用的就直接用,同时进行修改
    • 优点:快
  2. 最佳适应(最小适应)
    • 一种粗暴的思路是遍历全部空闲分区链
    • 另一种更好一点的思路是维持空闲分区链的有序性
      • 在修改后重新排序,因为分配只会导致减小,所以我们只需要对着前半截进行一次插入排序即可
    • 优点:保证大空间
    • 缺点:产生小碎片,慢
  3. 最坏适应(最大适应)
    • 与2反其道而行之
    • 优点:减少小碎片
    • 缺点:破坏大空间,慢
  4. 邻近适应
    • 对1的修改
    • 从上一次停下的位置开始查找,这样可以跳过前面因为分配而产生的小空间,快速用到后面的大空间
    • 缺点是破坏大空间
    • 优点是比首次适应还快

储存器分配------非连续分配

页式管理

基本思想

页式管理其实是分区的进化版,将分区粒度变得非常细,同时用页表建立索引,因此可以分散储存,大大提高空间利用率。

页表负责索引功能,将逻辑页号转为物理页号,这里区分一下名词:

  1. 逻辑页:对应程序,叫页,页面
  2. 物理页:对应内存,叫页框,页帧,物理块,物理页面,内存块

因为逻辑页是连续递增的,因此直接隐含在偏移地址里了,不在页表项里,而页表项的长度一定是要对齐的(k字节)

如何转换呢?

  1. 逻辑到物理:
    • 说白了就是用索引表的页号查找对应页框号,然后拼接就可以
    • 注意,页框号要乘系数才是页起始地址
  2. 物理到逻辑:
    • 1的逆过程,在二进制下其实很简单,直接截取地址,后半段就是页内偏移,前半段就是页框号
    • 本质在于,页框大小固定,因此两部分都是定长
地址变换硬件

学过汇编的话,这个过程非常熟悉。

因为页表位置可以浮动,我们干脆就用一个页表寄存器储存地址(PTR)

考虑到安全性检验,还要再存页表长度,这两个是分成两节存在一个寄存器里的

需要注意,既然是寄存器,那其实也是程序上下文,所以随着进程切换,肯定也会有装入和保存的过程

这个转换流程,用字母描述:

  1. P页号
  2. W页内偏移
  3. 需要注意的是越界验证,因为PTR存的是页表长度,所以是虚高1位的,因此只要P等于M,就算越界
  4. 我们都是手算,实际上计算机直接拼接就行

前面说到页表项大小要对齐到k字节,实际上不仅仅如此。

3B情况下,会产生页框内碎片,那么我如果要访问这个碎片地址上的页表项呢?那只能+1偏移,这样做很麻烦,而且容易出bug

所以干脆进行二次对齐,对齐到能够被页框大小整除,所以一般是用4字节,做题的时候要考虑这两种对齐。

快表(TLB)

参考cache原理,TLB其实就是页表的cache,材料也都是SRAM,只不过TLB的等级还要在cache之上,是最紧贴CPU的

TLB是一种cache,更具体的说,应该是全相联方式储存的模式。

因此快表不能像页表那样,把页号隐藏在地址里,而是多加一个字段,且每次要遍历快表。

查找过程有两种:

  1. 先查TLB,再查页表
  2. 同时查询

进而衍生出不同耗时·的计算结果

TLB和cache的区别:

  1. cache会缓存一整个内存块
  2. TLB只cache页表项
    • 从这个角度来看,其实TLB就是比cache更细,TLB是内存块的cache,而cache是整个内存的cache
多级页表

当一个页表存不下页表项,就需要用二级。

一般来说,只有二级页表,实际上可以多层

区分一下名称:

  1. 二级页表
    • 外层页表,或顶层页表,页目录表
    • 每一行:页目录项,页表描述符
  2. 一级页表
    • 每一行:页表项,页描述符

转换过程无非就是前N次确定最终页号,最后1次进行访存,即N+1次

页表具体分几级,要根据地址长度来定,先抛去页内偏移,之后看看能拆几节页号地址。

段式管理

首先要明确,段式管理和页式管理是并列的,都是非连续的分配。

段式管理很像动态分区,但领域不一样:

  1. 动态分区是给内存进行分区,分区表是针对内存的,每个分区对应一个进程
  2. 段式管理是给进程空间进行分区,段表是针对一个进程的,每个分区对应程序的一个内存段

段表和页式管理类似,每个段表项都是等长的,段号都是隐含的(但是段不等长)

寻址过程也很类似,都是两次+越界检测

越界也是同理,这个段长是具体长度,虚高,所以只要满足W=C就代表越界了

从设计理念上来说,段页还是不同的,如下:

  1. 页式管理完全是为了系统服务的
    • 是物理性的,纯粹按照地址切分的
    • 用户不可见
  2. 段式管理更多的是为了用户服务
    • 是逻辑性的,分模块的
    • 用户可见

由设计理念来引申,共享与保护:

  1. 因为段是逻辑的,我们共享的时候也是按照模块共享的,逻辑上非常直观
    • 比如我可以专门为可重入代码,或者共享数据建立一个段,这个段直接整体共享即可(不可重入代码不可共享)
    • 而页并不具备这种逻辑的整体性,一页里面可能啥都有
  2. 同理,段也更有利于保护,整个模块一起保护很方便
    • 页的内容很复杂错乱,所以共享管理很麻烦

定不定长也是一个区分点:

  1. 页式管理定长,因此给定一个逻辑地址,就可以直接通过除法运算锁定页号
    • 页式管理一维,给地址直接上线性地址
  2. 段式管理不定长,给一个逻辑地址,只能截取段号,而不是除法运算
    • 因此段式管理是二维的,给地址的时候要给两部分,段命(对应段号)和段内地址

段页式管理

终于到了段页式管理了,这才是版本真神。

段页式管理是页+段的综合,底层用页,高层用段。

另一种理解就是把二级页表爆改成段表了


段页式是两级的,所以访存次数是2+1=3

要进行两次越界判断,由此可得,其实二级页表也得进行两次越界判断。

注意,这个TLB是把段号和页号一起作为一个tag的,而不是弄两个TLB

虚拟储存器------基于交换的内存扩充技术

基本概念

虚拟内存的特征:

  1. 多次性:针对装入过程来说
  2. 对换性:内外交换
  3. 虚拟性:针对空间视图来说,看到的很大,但是是虚拟的

因为虚拟内存是把进程的内存空间拆分了,所以必须使用非连续性内存分配技术。

在此基础上,增添两个功能:

  1. 请求调入
  2. 置换

后面以页举例,更复杂的也是类似逻辑。

请求分页

请求分页逻辑可以参考cache来,其实是一个思想

但是具体还是不太一样:cache仅仅是缓存,管理能力很弱,而虚拟内存的管理能力很强,除了页框内容的缓存外,还专门有页表来管理页框,我们研究的其实是页表的管理。

请求页表结构:

  1. 首先,虚拟页表的管控对象是内存+外存
    • 管控对象到底在内存还是外存?因此要用状态位+内存块号+外存地址进行区分和寻址
  2. 其次,考虑置换过程
    • 置换哪一个?因此要有访问字段,辅助置换算法
    • 换出的时候是否要写回?因此有修改位,需要考虑是否被修改(类似cache脏位)

如果目标页的有效位=0,说明在外存,发生缺页中断。

注意,缺页中断并不是外中断,而是广义的中断,实际上是异常。

之后研究一下请求分页管理中的细节,其实和基本分页的区别无非就是两点:

  1. 额外的检查
    • 状态位
  2. 额外的修改
    • 外存:置换前是否写回外存
    • 页表:置换后页表的标志位要刷新
    • TLB:快表的有效位恒等于1,因此换出的时候,要TLB删除(否则出错),换入的时候也可以根据局部性原理将这个页表项复制到TLB

不过不得不说,这个过程真的挺复杂的,后面做题继续细化吧,你且知道相关联的三个部分就可以:外存,页表项(以及对应的页框),TLB

页面置换算法

这几个方法在我另一篇笔记里已经有详细的描述了,这里进行细化。

注意,页面置换次数≠缺页次数,缺页是要更加广泛的,注意题目问的是哪个。

首先是OPT

具体做的时候,就是从发生缺页的位置开始,查看后面要调用的页,在这里面找我们当前物理块里装的页,排在最后一个的就是要置换出去的。

然后是FIFOLRU,具体过程很简单:

  1. FIFO,有两种理解方式,效果相同,做题的时候自己看着办
    • 新进来的页会把原来的页推下去,末位淘汰,直观
    • 另一种理解方式是用一个指针指向即将要替换的位置,每次替换都让指针挪一位
  2. LRU,也是两种理解方式
    • 类似于FIFO的下推+末位淘汰,但是如果命中,就把这个块提到最上面(刷新存在感)
    • 另一种理解方式是逆向遍历访问序列,类似于OPT,最后一个出现的就是要淘汰的(只不过方向相反)
  3. 效果对比
    • FIFO有Belady异常,而LRU就没有
    • LRU效果是最接近OPT的,但是开销太大,需要硬件计时器(参考cache替换),要求的数量还不少。

再说时钟置换算法CLOCK(NRU)

思想很简单:

  1. 排成循环队列
  2. 命中,刷新访问位=1
    • 注意,命中不需要转时钟,指针不变
  3. 不命中,按照时钟方式扫描,进行替换
    • 1置0,访问位=1,相当于免死金牌
    • 0置换,访问位=0,则受斩
      • 置换后要将指针后移,防止这个新的页面在下一轮扫描的一开始就掉血

极限情况是进行1轮+1次扫描,也就是两轮扫描,这个方法兼顾了效率和效果。

改进NRU还考虑到了写回的IO损耗,尽可能避免IO(替换修改位=0的页面),同时还要维持原本NRU的原则,于是根据(访问位,修改位),可以分成4个优先级:

  1. 0,0,既没用,又没修改过,直接换
  2. 0,1,没用,但是被修改过,换的成本大点,但是造成的影响不大
  3. 1,0,用过,不得不换,只能找个换的成本小点的
  4. 1,1,成本最大,不得已的办法

具体如何去扫描呢?分4轮:

  1. 先在没访问过的里面扫两轮
    • 第一轮扫(0,0),
    • 第二轮扫(0,1),同时置零访问位
    • 第二轮才会像NRU一样置零访问位,因为这两轮整体并做对访问位的检查,所以只置零一次
  2. 之后在访问过的里面扫两轮
    • 注意,这两轮本来是(1,0),(1,1)的专长,但是因为第一组操作已经把访问位置0,所以走到这里的,肯定在第一组操作之前全部都是(1,x)的情况
    • 第三轮扫(0,0)
    • 第四轮扫(0,1),走到这一步一定会有一个页被置换出去
    • 这一组操作其实是针对修改位而来的

改进NRU非常的完美:

  1. 两组操作继承自NRU,对访问位的置0也和NRU完全一致
  2. 而在在两组操作内部,又加入了对修改位的考察

虽然改进NRU最多进行4轮考察,但是这点内存中的消耗和降低IO损耗带来的收益相比,微不足道

页面分配策略、抖动、工作集

之后介绍三种分配+置换的搭配:

  1. 固定分配+局部置换
    • 其实就是我们前面做题的时候用的思路
    • 当前进程和外存进行交换
  2. 可变分配+全局置换
    • 只要缺页,就增加物理块
    • 当前进程不直接和外存进行交换,而是直接用空闲的,或者从其他进程抢一个(未锁定)的页框过来
    • 之所以不直接,是因为抢夺其他进程页框,也会间接导致其他进程的交换,实际上还是要交换
    • 这个方法反而还不如局部置换稳定
  3. 可变分配+局部置换
    • 在1的前提下,如果系统察觉到1的缺页率比较高,就分配空闲块
    • 当然,3方法也存在抢夺物理块的情况,但是频率比2低多了
  1. 请求调页
    • 就是缺页中断,精确度很高,IO开销大
  2. 预调页策略
    • 目标是减少IO开销
    • 就是一种预测,因为其效果一般,所以只是在程序刚启动才这么干,这个时候调入不需要置换,就算翻车也无所谓。

再论从何处调页:

  1. 普通系统
    • 对换区大,那就全在对换区操作就行,因此要先复制到对换区再调入
    • 对换区小,因此要尽可能精细化,只把要修改的,可能反复IO的数据写回到对换区
  2. Unix系统
    • 介于普通系统的两个策略之间,精细度居中
    • 第一次是从文件区调入
    • 之后换出的页面,不管是否被修改过,都放到对换区

内存映射文件

传统文件读写,要进行内存文件的多级索引,比较麻烦,如果你不是一次性读入,那么每读一个块都要多级索引一次。

内存映射文件直接把文件索引一次性读到内存里,分出一些页表项直接把文件地址记录进去

出于效率考虑,这里只是分配了页表项,并没有将文件读入,但是后续的读入已经很简单了,不需要多级索引,只需要IO就可以,效率高多了。

修改只需要在内存中,这进一步减少了IO损耗,最后进程关闭文件的时候,才将文件一次性写回,非常方便。

总之,内存映射,既可以减少索引损耗,又可以减少IO损耗

文件映射还有另一个好处,就是便于共享文件。

注意区分页表项和物理页框,实际上读入后的文件是放在物理页框里的,我们说的共享只是让不同进程的页表项指向同一个页框。

文件管理

区分:

  1. 标识符vs文件名
    • 前者是OS内部用,后者给用户
  2. 外存地址vs文件目录
    • 前者给OS内部用,后者给用户

文件内部,和文件之间,都需要组织。

相关推荐
美式小田1 小时前
单片机学习笔记 9. 8×8LED点阵屏
笔记·单片机·嵌入式硬件·学习
猫爪笔记1 小时前
前端:HTML (学习笔记)【2】
前端·笔记·学习·html
_不会dp不改名_2 小时前
HCIA笔记3--TCP-UDP-交换机工作原理
笔记·tcp/ip·udp
-一杯为品-2 小时前
【51单片机】程序实验5&6.独立按键-矩阵按键
c语言·笔记·学习·51单片机·硬件工程
熙曦Sakura4 小时前
完全竞争市场
笔记
dr李四维5 小时前
iOS构建版本以及Hbuilder打iOS的ipa包全流程
前端·笔记·ios·产品运营·产品经理·xcode
Komorebi.py8 小时前
【Linux】-学习笔记05
linux·笔记·学习
亦枫Leonlew8 小时前
微积分复习笔记 Calculus Volume 1 - 6.5 Physical Applications
笔记·数学·微积分
冰帝海岸13 小时前
01-spring security认证笔记
java·笔记·spring
架构师Wu老七14 小时前
【软考】系统架构设计师-信息系统基础
系统架构·软考·系统架构设计师·信息系统基础