慢慢补:)
虚拟存储的需求背景和基本概念
虚拟存储的需求背景
我们知道物理内存有连续存储和非连续存储两种内存分配方式，虚拟存储是非连续存储的一个延续，在非连续存储的基础上，把一部分内容放到外存中去。这样做最直接的优点是可以让应用程序可以使用的空间更大，因为在应用程序看来，虚拟的内存和物理的内存是没有区别的；而最大的缺点也很明显，那就是访问外存的速度会比访问内存慢的多。
我想在我们谈虚拟存储需求背景这个题目时，更多是应该讨论的是它的优点。但是，你肯定会有这样的疑虑：
I have 16GB RAM, and never used more than 30% of it I have 6x GTX 1070 8GB GPUs I have a 32GB max page file size (16GB initial), and have never used more than 3.58% (140MB) in 5 months of profit switching mining as you can see from this chart from my monitoring tool (it logs usage every 10minutes)
My rig has barely touched it’s page file in 5 months. Just what is
different about your right that would require so much?
首先，我们对性能的渴望是永远不会停止的，当我们只有256M内存的时候，我们希望它可以跑512M的程序，当我们有16G的内存的时候，我们当然希望它能跑的程序更多。因此，这个机制是肯定要存在的，因为你不可能在发现程序跑不下去的时候出去买条内存条装上，即使这个概率非常小，你都不care，但操作系统的开发者们也不会允许这种情况发生。同时操作系统开发者们还要考虑的是哪些内存并没有那么大的同学要怎么跑程序，因此，在设计操作系统的时候，这个机制显然是不可少的。
其次要说的是它的价值并没有那么少，它的优点还在于以下几点：
(1)它使内存与进程之间，进程与进程之间保持隔离，这意味着它们无法访问其他数据或损坏它们。
(2)当使用某些函数或模块时，操作系统可能会“欺骗”一个程序，使其使用的内存超过可能。存储器可以在不使用时临时保存在辅助存储器中，然后在需要时切换回内存。
(3)内存不需要共享，因此所有程序都可以依赖于内存位置，而不必担心其他程序在同一位置加载。
虚拟存储的基本概念
我们首先来介绍一下覆盖和交换的概念，它们都是内存的扩充技术。但应该说明的是，由于它们自身的缺点，这两种技术已经很少被使用了。
覆盖(Overlay)和交换(Swap)
覆盖技术的目的简而言之是要在小内存中运行大程序。它的大致做法是把程序依据逻辑结构划分成若干个功能相对独立的模块，把相互之间没有调用关系、不会同时执行的模块分成一组，让它们在共享一块物理内存区域。通过这种共享，让整个进程占用的存储空间变小，从而在一个小内存的系统上能运行。同时这种共享也可以理解为，这两个模块同时覆盖了这块内存区域，因此覆盖就是这里来的。你可能会问，操作系统怎么可能知道一个程序内部的调用关系呢？的确，很遗憾，这个工作是要程序员来完成的，这项工作主要是在早期的操作系统中存在的。
它们共享一块内存区域 这样的话
我就可以让通过这种共享呢
让整个进程占用的存储空间变小
从而在一个小内存的系统上能运行
那具体说起来呢 在这里面呢我们就是
把程序的模块呢划分成必要的部分和可选部分
必要部分通常是一些常用的功能
而可选部分是些不常用 或者说在一些交替用的
那这些常用的呢让它常驻内存
而这些可选的部分呢 我只在它要用的时候
我把它装入内存 那有了这种做法之后呢
那是说这种不存在调用关系的
我可以把它相互覆盖
把它放到同一块内存区域里头来
好 那这种做法我们具体看看它怎么做呢
..
这地方呢给出来的是一个例子
说我有一个程序 它呢分成了六个模块
每个模块的大小呢在这儿有了标定
基本上是20 30 40 50这几个尺寸
然后它总共的大小呢是加在一起
是190K 那现在呢假定说
我在一个一台计算机系统上运行它
它的物理内存不够190K
那这时候你肯定没办法在上面运行了
好 那这时候呢我希望通过
我应用程序的处理使得可以让它能运行
那我们怎么办呢 先把它分成
按照相互独立的这几块
按照相互之间调用关系我把它分组
A和这些都有关系 它自己一组
B呢它和C E F都没关系
那我把C跟它分成一组
好 这个D呢 它肯定是要单独一组
因为这是一绺 好 那它和E和F是没有调用关系
它们俩可以在一组 E和F呢也是一样的
所以它们仨一组
这时候我怎么给它分配存储空间呢
是每一组里头我按它最大的来分配
那这时候呢我们分配完了是这样一种
A给20K B和C呢一个50 一个30我给50
剩下这个E F D这三个呢分别是30 20 40 我给40
我分了这样几块之后
那这时候它运行的时候会是啥样子呢
刚开始运行的时候A B和D在内存里头
它们之间运行 好运行到一段时间之后
那开始C调用的时候调用E
那这时候我把B和D换出去
然后把C和E拿进来
这时候在执行中间这一段
假定说你是在做数据处理
好 那它是可以运行的
好 等处理完了之后
那最后我要把结果输出来这是用的F
这时候F交换过来
因为这个F呢我们这一绺的大小
是以它们三块最大来弄的
所以这F放进来呢肯定是没问题的
好 用这种做法之后
我总共占用的存储空间是多少
40 50 20加在一起110 那它是可以运行的
好 那这样以来的话如果说你的系统里
只有110K的物理内存
那这个大一点的程序就没有办法运行
通过这种改造之后 使用覆盖技术
我写出来的程序跟你的功能是一样的
但是这时候它可以在110K的内存上运行
好 通过这种办法呢我可以
减少一个应用程序内存占用量
从而可以在小的 小内存的系统上运行
那这时候问这种做法需要了解这个关系
我现在这个画法是最优的吗
那实际上在这儿我们可以给出另一种划分办法
那A是独立一个模块
但是第二步呢我把B原来是和C放在一起
这俩差挺远
好 那这时候呢我把C B E和F放在一起
这两块呢它尺寸比较接近
好 那这时候我给它50K
而把最后一个呢C和D它俩放在一起
它俩都是30 这时候搁30
把这尺寸接近的放在一起之后呢
相互之间没有调用关系放在一起
好 这时候它合在一起
这几个加在一起是100 这个会更小
那是不是它是最小的
如果说你要严格去来讨论这个问题
那是相当复杂的 所以在这儿呢
这个给程序员的开销是很大的
那我们说在实际的系统里头呢
在我们的DOS操作系统上
这是历史上用过的 里头有个Turbo Pascal
那这是它的集成开发环境
使用Pascal语言的
好 那在这个环境里呢
它提供了这种Overlay的覆盖技术
那有了这个支持之后
那实际上它这里面是有一堆库支持
你在这里头呢这个模块的换入换出
和模块之间的关系的这种指定
好 那这时候说它的开发难度是会增加的
因为我要确定人首先要用程序员
来对模块进行划分 划分完了之后
还要确定它们之间的覆盖关系
那这时候呢 我的编程难度是增加的
与此同时我的执行时间呢也会有所增加
那这时候呢需要 原来我们执行的时候
是你把190K一块读入内存
然后你就开始执行了 后面就没有开销了
好 而在这儿呢
我不但要在刚开始的时候我读入一部分
那后来呢
我还会把另一部分再读进来
那这种呢就会导致你的执行时间会增强
那这种做法呢我们觉得它会有问题
好 另一种做法交换技术
这种做法呢是增加正在运行的程序
或者说需要运行程序的空间
这和我们前面说那个问题不太一样
说 我原来呢是一个程序的内存空间就不够用了
现在这儿呢 实际上讨论的是说
我一个程序你肯定要够用的
然后我只是当前这个程序呢
由于多道的程序运行使得
另一个应用程序占用了内存空间
使得它的空间不够
它并不讨论一个程序在所有内存空间里
用的时候它仍然不够的情况
好 那在这儿说 我们怎么做呢 你把那些
如果说你多个进程 同时在内存里头
我把那些另一些进程就把它暂停
并且放到外存里去
这样的话我的空间不就够用了吗
当前正在运行的或者说你需要运行的进程
它的地址空间就增大了
那这时候呢需要注意一条
它换入换出的基本单位是整个进程
那这个单位呢导致了不像我们刚才的
覆盖我是程序内部的事
好 然后 这时候有两个基本操作 一个是换出
我把一个进程的整个地址空间保存到外存里去
跟它对应着呢是换入 我把某个进程
在外存当中某个进程读到内存里头来让它能运行
那这是以进程为单位的交换技术
这种做法呢我们在前面也有这样一个示意图说
我在这里头两个进程 一个进程在内存里头
一个进程在外面 那现在说我要想让它运行
它需要的空间大 我就把它换出来
然后把它换进去 然后这样的话
它的空间呢就能够运行了
如果说这空间足够的时候呢
一半它也能进行的 我就可以让它俩在内存里头
这样你 你这个交替运行的时候
它的速度就很快 但这时候呢空间不够
好 这是交换
我们使用交换技术可以把一些
暂停执行的进程放到外存里头去
但这时候呢也会有一些麻烦
就是说首先第一个我们遇到麻烦
是说我在什么时候来进行交换
那这时候呢通常情况下我在内存不够的时候
或者有不够可能性的时候
比如说我一个正在执行的进程
它的内存空间不够用了
这时候我必须把另外一些暂停执行的
并且在内存里的
把它整个进程地址空间兑换到外存当中
这时候我这个可以扩大
另一种情况是说我有一个进程要执行
现在内存里可用的空闲空间不够用
好 那这时候我就把暂停的另外一些进程呢
倒到外存里面去 这时候它可以来运行
那这是时机
再有一个是交换区域的大小
也就是说我倒到外存里头去
放在外存里头这些进程映象
它要占多大空间呢
需要把所有的暂停的用户进程
全部保存到外存当中
这时候呢它是需要占用一定的存储空间的
还有一个问题是说 我换入的时候
那你是否能放回到原处呢 如果说不放回到原处
我原来的函数调用或者说有跳转 这些你怎么办
那这个时候呢我们说它的做法是
需要采用动态的地址映射的办法
而这些前面关于交换和覆盖的这种技术准备
都为我们的虚拟存储打下基础
好 那我们对它做一个比较 对于覆盖来说
它是在程序内部模块之间的
跟程序外边没关系 好 这时候它是一个进程
在物理空间里运行它就不够了
好 那这时候说我们需要兑换的呢
覆盖进行交换的呢是这个
没有调用关系的模块之间
程序员必须知道这种逻辑覆盖关系
这是比较麻烦的
而对于交换来说呢它是以进程整个地址空间
为单位来进行交换的
这时候呢我们不需要这个逻辑关系
它只会发生在进程之间
好 这一部分呢实际上可以由操作系统来做的
那上边这一部分可不可以由操作系统来做呢
那这事有难度 原因在于这地方这种逻辑关系
你操作系统没有办法很准确掌握的
好 那这样的话是说 我有没有可能以使用
由操作系统来做同时呢
我又是不是以整个进程为单位
是一部分一部分的
进程地址空间的一部分内容
我把它导入到外存里头去
这个时候有没有可能呢
那这就是我们下面要说到的
虚拟存储要来做的事情
…
…
局部性原理
接下来我们介绍虚拟存储当中的局部性原理
那我们在这里说虚拟存储是想
把原来放到内存里的这个进程地址空间的信息
把其中的一部分放到外存当中来
那要把它放到外存当中来呢
实际上这时候呢需要有一系列的准备工作
那我们首先看一下
我们在这里头如何把这个放到外存里头来
我们想达到的目标具体准确的描述出来
这是我们虚拟存储希望达到的效果
进程地址空间实际的物理内存和外存
这两个搁在一起呢
来存放地址空间的内容
这一些呢放在内存一些放到外存里头
中间呢是由操作系统来干这件事情
那我们把这个目标具体的描述出来呢
就有这样两条 第一条是说
我们只让一部分程序加载到内存当中来
这时候呢就可以让程序运行
那这是跟以前不一样的
以前我们说要想一个程序运行
我必须把整个进程加到地址空间当中
那这时候才能开始运行 只加一部分让它
怎么能让它运行起来
那这时候呢需要我们做的是说要操作系统
自动的来完成我需要加载哪一部分
而不需要程序员的参与
而在我们前面用的覆盖技术呢
这是需要程序员来参与的
另一个呢是说我们可以把一部分
内存空间当中的信息放到外存当中去
内存和外存之间做一个交换
这样做的目的是让正在运行的进程
能够有更多的空闲空间
而这一条也是需要由操作系统来做
它在内外存之间进行交换
需要讨论的问题是说我到底要把哪些东西放出去
实际上这时候我们前面说的第一个
我到底要把哪些东西放进来
这是我用到的放进来
这个地方我把哪个东西放出去呢
实际上是说我需要把不常用的放到外存当中去
这就是我们后面会说到的置换算法
那在具体讨论之前呢
我们需要来讨论程序访问的一些特征
这就是我们这里说到的局部性原理
所谓局部性原理呢是指程序在执行的过程当中
在一个较短的时间里头
它所执行的指令和指令操作数的地址
分别局限于在一定区域里头
因为通常情况下我们指令是存在代码段里的
指令所访问的操作数呢通常是存在数据段里的
这两个呢各是一个地方
那这两个各自一个地方呢
分别局限在一定区域里头
这怎么说呢 这种特征呢体现在以下几个方面
第一个呢叫时间局部性
也就是说我一条指令的连续两次执行
我一个数据的连续两次访问 通常情况下
它们都集中在一段较短的时间里头
正是因为有了这种较短的时间所以我可以把
放到内存里的这一段内容 它会频繁的访问
如果没这一条的话可能出现一种什么样的情况
就是你刚放进来内存里的这个信息
下一步要访问另一个你刚拿出去的
如果出现这种极端情况的话
你这个虚拟存储就性能大幅度下降了
好这是时间局部性
另一个呢是说空间局部性
空间局部性是指我相邻的几条指令
或者说我访问的相邻的几个数据
访问区域呢是局限在一个较小的区域里头
也就是说我相邻的访问的两条指令
相邻访问的两个数据
比如说我们在对数据进行排序的时候
那我会有循环
那这个循环呢就是你要访问这几条指令
而我排序的相邻这些数据呢
那就是你这儿要访问的数据
它们呢通常情况下是局限在一个较小的区域里头
再有一条呢是叫分支局部性
分支局部性是指什么呢 说我有一条跳转指令
这跳转指令的两次执行呢很多时候
它是会跳转到同一个地址的
这种情况在实际的例子中会是什么样的
比如说我有一个循环 循环一千次
那进到这个循环体里头
到那个循环的跳转指令的地方
判断小于你的循环次数
它就蹦回到开头 那这样的话
你从这条指令上来看
前面只要没到你的循环次数
那前面都是蹦到开头
那这样的话只有最后一次是例外
好 那这种呢我们称之为叫分支局部性
有了这几条之后我们就可以认为
我们所运行的程序它具有它所执行的指令
所访问的数据有很好的这种集中特征
它们会集中在一个局部的区域里头
那这样的话如果我们能够判断清楚
它局限在的那个区域到底是哪些
我们可以对它做很好的预测的话
那这时候我们就可以把这些内容放到内存里头来
而把那些不常用的放到外存当中
而这种经常用的放到内存里头之后
那我们的计算的程序执行的性能
就不会有大幅度下降 这也是由于这一条
我们局部性原理 那从理论上呢保证了
我们虚拟存储它是可能实现的
它具有可行性 并且呢
它实现完了之后应该能有很好的这个效果
好 那具体呢我们通过一个例子来说明
说这个局部性到底体现在什么地方
同时这种局部性
也跟我们写的程序特征是有关系的
在这儿给一个例子
说我在这里呢4K为一个页面
然后我给一个进程呢 这仅仅是个示例
分配一个页面这是用来放数据的
好 那这里头我约定一个二维数组
那1024乘1024 假定你的int是整数呢
是占四个字节为一个整数
好 那这时候呢我在这个页面
再被这个数组呢进行清零
我们看它访问的次数会是啥样的
好 清零呢 我来写我这程序的时候呢
这是一种写法 两个循环
二维数组第一维第二维
那需要大家注意的是我第一维呢
在里头这个循环是用的第一个下标
在外头这个循环是用的第二个下标
而还有一种另外的写法 我把它反过来
i j i j 这样的话在里头那个小循环里头
那我是先循环的第二位
那如果说我们在实际的存储当中
它的存储顺序和你这两个循环
实际上它在访问的时候
它的位置的分布呢是很不相同的
那我们具体看一下这两个到底会有什么样的情况
那这是呢我们看到的刚才那个
二维数组它在存储空间当中的情况
这里呢每一行代表一页
你比如说每个元素我占四个字节
1024个刚才说的4K 4K我占一页
我们用来存数据的呢 分配的页面是
物理页面是一个 那这样的话我每使用一行
蹦到下一行的时候我就会产生缺页
那对应着我们刚才前面的两种清零的办法
那第一种办法呢 我是从第一个元素
然后它并不是在这一页里的第二个
而是第二页里的第一个
一直到最后一页的第一个
然后再是 这样循环下来的
我们看它 它的访问顺序 第一页一直到1023
然后又是第0页到1023
这样的话我每一次相邻的一次访问
我都会切到下一页 那这种切换呢会导致一次缺页
那这样总共缺页次数是什么
就是1024乘1024 而我们的第二种做法呢
它的访问方式是先把这一行全部清零
然后再把第二行全部清零
如果说 你意识到背后是虚拟存储
那么这时候呢这地方的缺页次数
就变成了1024次
如果说你认为这些数据全在内存里头
那么这两种做法
我们在内存里头任何一个单元在访问的时候
它都是使用的时间是一样的
那这两种算法是没有区别的
好 如果说我们在这里头考虑到物理内存的量小
那么这时候呢这两种做法
它的区别呢就是巨大的
所以在这儿呢不同的程序
如果说你背后利用了虚拟存储
那你在这里头呢需要很小心的
去使用你的编程方法 以便于提高它的局部性
这个提高它的局部性
也有利于提高你的程序的这个性能
好 基于这样一种做法呢
我们说在这里头它可以很好的有局部性的特征
那接下来我们会说基于这种局部性的特征
我们怎么来实现我们的虚拟存储系统
…
…
…
…
…