--请求分页
请求分页的基本功能
请求分页的基本功能分页是现代印刷技术的基本功能之一，它能够将大篇幅的内容分割成更小的部分，帮助读者更好地理解和阅读。
无论是纸质书籍还是电子文档，分页都起到了重要的作用。
本文将从分页的定义、历史、应用和未来发展等方面介绍分页的基本功能。
分页是指将一段较长的文章、书籍或文档分割成若干页，每页包含一定数量的文字、图片或其他内容。
通过分页，读者可以更方便地阅读、理解和处理文本信息。
分页的功能不仅仅局限于纸质媒介，现代电子设备也广泛应用了分页技术，使得用户能够更好地浏览和查找文档内容。
分页的历史可以追溯到古代的手抄书时代。
在手写时代，书籍往往是由人工撰写和制作的，一页一页地书写，然后用线或绳子将它们连接在一起。
这种分页方式虽然原始，但已经具备了基本的分页功能。
进入印刷术时代后，人们开始使用排版技术，将文字和图像按照一定规律排列在页面上，并进行分页。
这种印刷分页方式为后来的印刷品提供了基本的结构和阅读方式。
随着计算机技术的发展，分页的应用范围逐渐扩大。
在电子文档出现后，人们可以更方便、快捷地进行分页操作。
通过电子设备的软件功能，用户可以自由地设置页面大小、行距、段落样式等，实现个性化的分页效果。
此外，电子设备还提供了便捷的页面导航功能，用户可以通过滚动、缩放、翻页等操作方式快速浏览和定位文档内容。
分页的基本功能在现代社会中发挥着重要的作用。
首先，分页使得大量的信息更易于阅读和消化。
在信息爆炸的时代，人们需要从海量的信息中获取有效的内容，而分页能够将复杂的信息分割成更小的单元，有助于提高阅读效率。
其次，分页也为文档的排版提供了基础。
无论是书籍、报纸、杂志还是宣传册，都依赖于分页来实现良好的版面效果。
最后，分页也为协同编辑和团队合作提供了方便。
多人合作编辑一个文档时，可以通过分页将任务分割成若干部分，每个人负责一个或几个页面的编辑，提高工作效率。
未来，分页的功能可能会进一步扩展和创新。
随着人工智能和自然语言处理技术的发展，未来的分页系统可能会更智能化。
16存储管理5请求页式管理请求段式管理2
7
0
采用最佳置换算法，只发生了6次页面 置换，发生了9次缺页中断。缺页率=9/21
17
2、先进先出页面置换算法（FIFO） 这是最早出现的置换算法，这种算 法总是淘汰最先进入内存的页面，选 择在内存中驻留时间最久的页面予以淘 汰。
18
采用FIFO算法进行页面置换时的情况。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 1 7 0 1 7 7 0 7 2× 2 2 4× 4 4 0× 0 0 7× 7 7 0 0 3× 3 3 2× 2 2 1× 1 1 0× 0 1 1 1 0× 0 0 3× 3 3 2× 2 2 1× 3 4 5 6 7 8 9 10 11-13 14 15-18 19 20 21
次数减少；不同的计算机系统，有不同页面大小；
11
（3）程序的编制方法
例：程序要把128×128的数组初值置“0”，数组 中每一个元素为一个字，假定页面大小为128个字， 数组中的每一行元素存放一页，能供该程序使用 的主存块只有1块。初始时第一页在内存； 程序编制方法1： 程序编制方法2： For j:=1 to 128 For i:=1 to 128 For i:=1 to 128 For j:=1 to 128 A[i][j]:=0; A[i][j]:=0; 按列：缺页中断次数： 按行：缺页中断次数 128-1 128×128－1
21
D A D A C D B C + +
B B A D +
E E B A +
A B C D E E E C D D B B E C C A A B E E + +
请求分页实验报告
一、实验目的1. 理解请求分页的基本原理和实现方法。
2. 掌握操作系统内存管理的基本知识。
3. 提高编程能力和系统设计能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C/C++3. 开发环境：Visual Studio 2019三、实验原理请求分页是一种内存管理策略，其基本思想是当进程访问内存中的某页时，如果该页不在内存中，则从磁盘读取该页到内存，并将内存中的一部分页调出磁盘。
请求分页可以提高内存的利用率，避免内存碎片。
四、实验内容1. 设计请求分页系统2. 实现请求分页算法3. 测试请求分页系统的性能五、实验步骤1. 设计请求分页系统（1）定义数据结构定义进程结构体、内存块结构体、页面表结构体等。
（2）初始化系统初始化内存块、页面表、进程队列等。
（3）请求分页算法实现实现FIFO、LRU、LFU等请求分页算法。
2. 实现请求分页算法（1）FIFO算法FIFO（先进先出）算法是最简单的请求分页算法，当请求分页时，总是选择最先进入内存的页面调出。
（2）LRU算法LRU（最近最少使用）算法选择最近最少被访问的页面调出，可以有效减少缺页中断。
（3）LFU算法LFU（最少使用频率）算法选择使用频率最低的页面调出，适用于页面使用频率不均匀的情况。
3. 测试请求分页系统的性能（1）定义测试用例设计一系列测试用例，包括不同大小的进程、不同类型的页面访问模式等。
（2）运行测试用例运行测试用例，记录缺页中断次数、页面命中率等性能指标。
（3）分析结果分析测试结果，比较不同请求分页算法的性能。
六、实验结果与分析1. 实验结果通过实验，我们得到了以下结果：（1）FIFO算法：缺页中断次数为50，页面命中率为90%。
（2）LRU算法：缺页中断次数为30，页面命中率为95%。
（3）LFU算法：缺页中断次数为35，页面命中率为92%。
2. 分析结果从实验结果可以看出，LRU算法在三种算法中性能最好，其次是LFU算法，FIFO算法性能最差。
【UNI-APP】分页请求数据列表
【UNI-APP】分页请求数据列表// ⾸先在对应的pages.json⽂件中，配置刷新效果{"path" : "pages/list/list","style" :{"navigationBarTitleText": "房源列表","enablePullDownRefresh": true}}// 在methods⾥⾯定义请求数据接⼝// 请求第1页的数据getList() {this.listData = []uni.request({url: 'http://localhost:8000/api/house/list?page=1&size=7',method: "POST",header: {'content-type': 'application/x-www-form-urlencoded'},data: {style: 1,},success: (ret) => {uni.stopPullDownRefresh(); // 停⽌当前页⾯刷新if (ret.data.code == 200) {ret.data.data.some((item, i) => {this.listData.unshift({title: item.title,price: item.price,id: item.id,image: "http://localhost:8000" + item.image,time: item.time,})})// this.banner = data.data;}},fail: (data, code) => {console.log('fail' + JSON.stringify(data));}})},// 请求第N页的数据/* 分页请求 */getPageList() {uni.request({url: 'http://localhost:8000/api/house/list?page=' + this.page + '&size=7',method: "POST",header: {'content-type': 'application/x-www-form-urlencoded'},data: {style: 1,},success: (ret) => {console.log(ret)uni.stopPullDownRefresh(); // 停⽌当前页⾯刷新if (ret.data.code == 200) {this.page = this.page + 1 // 页⾯+1ret.data.data.some((item, i) => {this.listData.push({title: item.title,price: item.price,id: item.id,image: "http://localhost:8000" + item.image,time: item.time,})})} else {/* 如果接⼝报错就是没数据加载消失 */ // <!-- 下拉加载 --> 加载HTML // <view style="text-align: center;width: 100%;"> // <u-loading mode="circle" :show="show" size="36">加载中...</u-loading> // </view>this.show = false}},fail: (data, code) => {}})},// 下⾯是下拉上啦的配置函数onLoad() {/* 列表 */this.getList();},onPullDownRefresh() {/* 下拉的时候更新 */this.getList();},onReachBottom() {// console.log("向下拉")//此处使⽤定时器可查看出下拉刷新效果setTimeout(() => {this.getPageList(() => {uni.stopPullDownRefresh()})}, 1000)},// 完整代码<template><view><!-- 输⼊框搜索 --><view><topSearch></topSearch></view><!-- 下拉菜单 --><u-dropdown><u-dropdown-item v-model="housePrice" title="价格⾼低" :options="optionsPrice" @change="changePrice"></u-dropdown-item><u-dropdown-item v-model="houseTime" title="发布时间" :options="optionsTime" @change="changeTime"></u-dropdown-item></u-dropdown><!-- 商品列表 --><view class="uni-list"><view class="uni-list-cell" hover-class="uni-list-cell-hover" v-for="(value,key) in listData" :key="key" @click="detail(value.id)":pk="value.id"><view class="uni-media-list"><image class="uni-media-list-logo" :src="value.image"></image><view class="uni-media-list-body"><view class="uni-media-list-text-top">{{value.title}}</view><text>123</text><view class="uni-media-list-text-bottom"><text>{{value.price}}</text><text>{{value.time}}</text></view></view></view></view></view><!-- 下拉加载 --><view style="text-align: center;width: 100%;"><u-loading mode="circle" :show="show" size="36"></u-loading></view></template><script>import topSearch from "@/components/topSearch/topSearch.vue" var dateUtils = require('../../utils/util.js').dateUtils;export default {components: {topSearch},data() {return {/* 商品列表 */listData: [],last_id: "",reload: false,page: 1,show: true,/* 下拉菜单 */sort:1,houseprice: 1,houseTime: null,optionsPrice: [{label: '默认排序',value: 1,},{label: '从低到⾼',value: 2,},{label: '从⾼到低',value: 3,}],optionsTime: [{label: '最近发布',value: 4,},{label: '最早发布',value: 5,},],}},methods: {/* 跳转详情 */detail(goods_id) {/* 记录商品主键 */// uni.setStorageSync('goods_id',)console.log(goods_id)// uni.navigateTo({// url: '/pages/detail/detail'// })},/* 下拉菜单 */changePrice() {this.sort = this.housePricethis.getList()},changeTime() {this.sort = this.houseTimethis.getList()},/* 刚进⼊请求接⼝ */getList() {/* 初始化参数 */this.page = 1this.listData = []uni.request({url: 'http://localhost:8000/api/house/list?page=1&size=7',method: "POST",header: {'content-type': 'application/x-www-form-urlencoded'},data: {style: uni.getStorageSync('style'),sort:this.sort},success: (ret) => {uni.stopPullDownRefresh(); // 停⽌当前页⾯刷新if (ret.data.code == 200) {this.page = this.page + 1ret.data.data.some((item, i) => {this.listData.unshift({title: item.title,price: item.price,id: item.id,image: "http://localhost:8000" + item.image,time: item.time,})})this.show = false}},fail: (data, code) => {console.log('fail' + JSON.stringify(data));}})},/* 分页请求 */getPageList() {this.show = trueuni.request({url: 'http://localhost:8000/api/house/list?page=' + this.page + '&size=7', method: "POST",header: {'content-type': 'application/x-www-form-urlencoded'},data: {style: uni.getStorageSync('style'),sort:this.sort},success: (ret) => {// console.log(ret)uni.stopPullDownRefresh(); // 停⽌当前页⾯刷新if (ret.data.code == 200) {this.page = this.page + 1ret.data.data.some((item, i) => {this.listData.push({title: item.title,price: item.price,id: item.id,image: "http://localhost:8000" + item.image,time: item.time,})})} else {/* 如果接⼝报错就是没数据加载消失 */this.show = false}},fail: (data, code) => {this.show = false}})},},/* 列表 */this.getList();},onPullDownRefresh() {/* 下拉的时候更新 */this.getList();},onReachBottom() {console.log("向下拉")//此处使⽤定时器可查看出下拉刷新效果 setTimeout(() => {this.getPageList(() => {uni.stopPullDownRefresh()})}, 1000)},}</script><style>/* 列表 */.banner {height: 360upx;overflow: hidden;position: relative;background-color: #ccc;}.banner-img {width: 100%;}.banner-title {max-height: 84upx;overflow: hidden;position: absolute;left: 30upx;bottom: 30upx;width: 90%;font-size: 32upx;font-weight: 400;line-height: 42upx;color: white;z-index: 11;}.uni-list {background-color: #FFFFFF;position: relative;width: 100%;display: flex;flex-direction: column;}.uni-list:after {position: absolute;z-index: 10;right: 0;bottom: 0;left: 0;height: 1px;content: '';-webkit-transform: scaleY(.5);transform: scaleY(.5);background-color: #c8c7cc;}.uni-list::before {position: absolute;z-index: 10;right: 0;top: 0;left: 0;height: 1px;content: '';-webkit-transform: scaleY(.5);transform: scaleY(.5);background-color: #c8c7cc;}.uni-list-cell {position: relative;display: flex;flex-direction: row;justify-content: space-between; align-items: center;}.uni-list-cell-hover {background-color: #eee;}.uni-list-cell::after {position: absolute;z-index: 3;right: 0;bottom: 0;left: 30upx;height: 1px;content: '';-webkit-transform: scaleY(.5);transform: scaleY(.5);background-color: #c8c7cc;}.uni-list .uni-list-cell:last-child::after { height: 0upx;}/* 图⽂列表 */.uni-media-list {padding: 22upx 30upx;box-sizing: border-box;display: flex;width: 100%;flex-direction: row;}.uni-navigate-right.uni-media-list { padding-right: 74upx;}.uni-pull-right {flex-direction: row-reverse;}.uni-pull-right>.uni-media-list-logo { margin-right: 0upx;margin-left: 20upx;}.uni-media-list-logo image {height: 100%;width: 100%;}.uni-media-list-text-bottom {width: 100%;line-height: 30upx;font-size: 26upx;color: #8f8f94;}.uni-media-list-logo {width: 180upx;height: 140upx;margin-right: 20upx;}.uni-media-list-body {display: flex;flex: 1;flex-direction: column;justify-content: space-between; align-items: flex-start;overflow: hidden;height: auto;}.uni-media-list-text-top {width: 100%;line-height: 36upx;font-size: 30upx;height: 74upx;font-size: 28upx;overflow: hidden;}.uni-media-list-text-bottom {display: flex;flex-direction: row;justify-content: space-between; }/* 列表 */</style>。
clock算法和请求分页EAT计算
若循环链表存在当前访问页时（访问页在某物理块中），直接将其访问位改为1，指针p 不移动（命中后指针不移动）；否则，若当前p指针指向页面的访问位为0，则淘汰该页，调入新页，将其访问位改为1，指针p 移到下一个物理块；若当前p指针指向页面的访问位为1，则将其访问位改为0，并移动p指针到下一个物理块，并重复查找。
假设系统为某进程分配了3个物理块，考虑页面走向为：7、0、1、2、0、3、0、4，求采用CLOCK页面淘汰算法时缺页中断的次数。
表1-1 CLOCK算法的详细流程基本分页管理方式中有效访问时间的计算有效访问时间（EAT ），是指给定逻辑地址找到内存中对应物理地址单元中的数据所用的总时间（1） 没有快表的情况访存一次所需的时间为t ，有效访问时间分为：查找页表找到对应页表项，需要访存一次，消耗时间t ；通过对应页表项中的物理地址访问对应内存单元，需要访存一次，消耗时间t 。
因此，EAT=t+t=2t （2） 存在快表的情况设访问快表的时间为a ，访存一次时间为t ，快表的命中率为b ，则有效访问时间分为：查找对应页表项的平均时间()(1)a b t a b ⨯++-。
其中a 表示快表命中所需的查找时间；t+a 表示查找快表未命中时，需要再访存读取页表找到对应页表项，两种情况的概率分别为b 和1-b ，可以计算得到期望值，即平均时间。
通过页表项中的物理地址访存一次取出所需数据，消耗时间t 。
因此，()(1)EAT a b t a b t =⨯++-+请求分页管理方式中有效时间的计算与基本分页管理方式相比，请求分页管理方式中多了缺页中断这种情况，需要耗费额外的时间，因此计算有效访问时间时，要将缺页这种情况考虑进去。
首先考虑要访问的页面所在的位置，有如下三种情况。
访问的页在主存中，且访问页在快表中（在快表中就表明在内存中），则EAT=查找快表时间+根据物理地址访存时间=a+t●访问的页在主存中，但不在快表中，则EAT=查找快表时间+查找页表时间+修改快表时间+根据物理地址访存时间=a+t+a+t=2(a+t).●访问的页不在主存中（此时也不可能在快表中），即发生缺页，设处理缺页中断的时间为T（包括将该页调入主存，更新页表和快表时间），则EAT=查找快表时间+查找页表时间+处理缺页时间+查找快表时间+根据物理地址访存时间=a+t+T+a+t=T+2(a+t)接下来加入缺页率和命中率，将上述3种情况组合起来，形成完整的有效访问时间计算公式。
请求式分页的页表结构
请求式分页的页表结构
请求式分页的页表结构一般由两部分组成，一部分是索引页表，另一部分是数据页表。
索引页表包含了所有缺页的页表项，其结构与传统的页表相同，包括页号和页框号等信息，但是由于是请求式分页，所以只记录了缺页的页表项，并没有记录已存在物理内存中的页表项。
索引页表记录了每个缺页所在的虚拟页面的页号和物理内存的页框号，以便当进程访问该虚拟页面时，系统能够快速将该虚拟页映射到物理内存中的地址。
数据页表则包含了所有已存在物理内存中的页表项，其结构与传统的页表相同，包括页号和页框号等信息。
数据页表记录了每个虚拟页面所在的页号和物理内存的页框号，以便当进程访问该虚拟页面时，系统能够直接将其映射到物理内存中的地址，从而提高了访问速度。
同时，在数据页表中也可以记录该虚拟页面的访问权限信息。
请求式分页的页表结构需要根据具体的操作系统和处理器进行调整和改进，以适应不同的环境和需求。
一些现代操作系统提出了更加高效的页表结构，如多层哈希页表和倒排页表等。
这些结构都有其特点和优劣，需要根据实际情况进行选择。
第16讲 存储器管理之请求分页存储管理方式
第十六讲存储器管理之请求分页存储管理方式1 基本概述请求分页管理是建立在基本分页基础上的，为了能支持虚拟存储器而增加了请求调页功能和页面置换功能。
基本原理：地址空间的划分同页式；装入页时，可装入作业的一部分(运行所需)页即可运行。
2 请求分页的硬件支持为实现请求分页，需要一定的硬件支持，包括：页表机制、缺页中断机构、地址变换机构。
2.1 页表机制作用：将用户地址空间的逻辑地址转换为内存空间的物理地址。
因为请求分页的特殊性，即程序的一部分调入内存，一部分仍在外存，因此页表结构有所不同。
如图：说明：（1）状态位P：指示该页是否已调入内存。
（2）访问字段A：记录本页在一段时间内被访问的次数或最近未被访问的时间。
（3）修改位M：表示该页在调入内存后是否被修改过。
若修改过，则换出时需重写至外存。
（4）外存地址：指出该页在外存上的地址。
2.2 缺页中断机构在请求分页系统中，每当所要访问的页面不在内存时，便产生缺页中断，请求OS将所缺的页调入内存。
缺页中断与一般中断的区别：（1）在指令执行期间产生和处理中断信号（2）一条指令在执行期间，可能产生多次缺页中断2.3 地址变换机构请求分页系统的地址变换机构。
是在分页系统地址变换机构的基础上，又增加了一些功能。
例：某虚拟存储器的用户空间共有32个页面，每页1KB，主存16KB。
假定某时刻系统为用户的第0、1、2、3页分别分配的物理块号为5、10、4、7，试将虚拟地址0A5C和093C 变换为物理地址。
解：虚拟地址为：页号（2^5=32）5位页内位移（1K =2^10=1024）10位物理地址为物理块号（2^4=16）4位因为页内是10 位，块内位移（1K =2^10=1024）10位虚拟地址OA5C对应的二进制为：00010 1001011100即虚拟地址OA5C的页号为2，页内位移为1001011100，由题意知对应的物理地址为：0100 1001011100即125C同理求093C。
操作系统第四章复习
页框号为21。 因为起始驻留集为空， 而0页对应的ห้องสมุดไป่ตู้框为空闲链表中的第三个空闲页框，其对应的页框号为21。
页框号为32。 因为11 > 10故发生第三轮扫描，页号为1的页框在第二轮已经处于空闲页框链表中，此刻该页又被重新访问，因此应被重新放回到驻留集中，其页框号为32。
页框号为41。 因为第2页从来没有被访问过，不在驻留集中。因此从空闲链表中取出链表头的页框，页框号为41。
4. 在虚拟内存管理中，地址变换机构将逻辑地址转换为物理地址，形成该逻辑地址的阶段是（ ）。 ① 编辑 ② 编译 ③ 链接 ④ 装载 5. 采用段式存储管理的系统中，若地址用24位表示，其中8位表示段号，则允许每段的最大长度是_______ A）224 B）28 C） 216 D） 232 6. 作业在执行中发生了缺页中断，经操作系统处理后，应让其执行______指令。 A）被中断的前一条 B）被中断的后一条 C）被中断的 D） 启动时的第一条
7、某基于动态分区存储管理的计算机，其主存容量为55MB（初始为空），采用最佳适配（Best fit）算法，分配和释放的顺序为：分配15MB，分配30MB，释放15MB，分配6MB，此时主存中最大空闲分区的大小是（ ） A：7MB B：9MB C：10MB D：15MB
当该进程执行到时刻260时，要访问逻辑地址为17CAH的数据，请问答下列问题： （1）该逻辑地址对应的页号是多少？ （2）若采用先进先出置换算法，该逻辑地址对应的物理地址是多少？要求给出计算过程。 （3）若采用时钟置换算法，该逻辑地址对应的物理地址是多少？（设搜索下一页的指针沿顺时针方向移动，且当前指向2号页框）
页号
存储块号
0 1 2 3
5 10 4 7
请求分页式存储管理的地址转换过程实现
第2部分、请求分页式存储管理的地址转换过程实现：●基本要求：在第1部分实验基础上实现进程的分页式内存分配和地址转换过程，并进一步实现请求分页式存储分配和地址转换过程。
页面置换算法至少应实现先进先出（FIFO ）、最近最久未使用（LRU ）等算法。
●参考学时：16学时 ●实验提示：1、建立一个位示图，用来模拟内存的分配情况，位示图的位数与设定的物理块个数相同。
程序启动时可利用一组随机0和1填充位示图，表示内存已被占用情况。
假设内存容量为64K ，块大小为1K ，则共有64个块，对应的位示图可能的值如下：该位示图表示内存的2（0字节第2位）、3（0字节第3位）、6（0字节第6位）、8（1字节第0位）、9（1字节第1位）、12（1字节第4位）、15（1字节第7位）…等块没有被占用。
2、创建进程时输入进程大小，并根据程序中设定的物理块大小为进程分配物理块，同时建立页表。
例如，在上图基础上，若要建立一个大小为5000字节的进程，则：● 计算出该进程共有“向上取整（5000/1024）=5”个页，需要占用5个内存块；● 建立空的页表，即长度为5的一维整数数组；● 从位示图中找出前5个“0”位在整个位示图中的位置号（即i 字节j 位为0，则该位的位置为8*i+j ），并将这些号依次填入页表中，同时把前5个“0”改为“1”，以示对应内存块已经分配。
第0字节 1 0 1 1 0 0 1 1 第2字节 1 1 1 0 0 1 1 1 第4字节 0 0 0 1 1 1 1 1 第6字节1 1 1 1 1 0 0 0第1字节 0 1 1 0 1 1 0 0 第3字节 1 0 0 0 0 1 1 1 第5字节 0 1 1 1 0 0 1 1 第7字节0 0 0 0 0 0 0 13、输入当前执行进程所要访问的逻辑地址，并将其转换成相应的物理地址。
4、进程退出时，根据其页表内容向位示图反向回填“1”。
5、扩充页表，将其变成支持请求和置换功能的二维页表（增加存在位等）。
实验六请求分页存储管理
实验六：请求分页存储管理一．实验目的深入理解请求页式存储管理的基本概念和实现方法，重点认识其中的地址变换、缺页中断、置换算法等实现思想。
二．实验属性该实验为综合性、设计性实验。
三．实验仪器设备及器材普通PC386以上微机四．实验要求本实验要求2学时完成。
本实验要求完成如下任务：（1）建立相关的数据结构：页表、页表寄存器、存储块表等；（2）指定分配给进程的内存物理块数，设定进程的页面访问顺序；（3）设计页面置换算法，可以选择OPT、FIFO、LRU等，并计算相应的缺页率，以比较它们的优劣；（4）编写地址转换函数，实现通过查找页表完成逻辑地址到物理地址的转换；若发生缺页则选择某种置换算法（OPT、FIFO、LRU等）完成页面的交换；（5）将整个过程可视化显示出来。
实验前应复习实验中所涉及的理论知识和算法，针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。
实验后认真书写符合规范格式的实验报告（参见附录A），并要求用正规的实验报告纸和封面装订整齐，按时上交。
三、设计过程3.1算法原理分析OPT算法是未来最远出现，当当前内存中没有正要访问的页面时，置换出当前页面中在未来的访问页中最远出现的页面或再也不出现的页面。
FIFO算法是先进先出，当当前内存中没有正要访问的页面时，置换出最先进来的页面。
LRU算法是最近最久未使用，当当前内存中没有正要访问的页面时，置换出在当前页面中最近最久没有使用的页面。
3.2数据定义int length,num_page,count,seed; //length记录访问串的长度，num_page页面数，count记录缺页次数int result[20][30],order[30],a[10]; //result记录结果,order存储访问串,a存储当前页面中的值int pos1,flag1,flag2,flag3; //pos1位置变量，flag1等为标志变量 char result1[30]; //记录缺页数组 void opt() //最佳void fifo() //先进先出bool search(int n) //查找当前内存中是否已存在该页3.3流程图与运行截图图6.1 FIFO （）函数流程图;否是 是否 开始得到执行的指令指令是否在内存中最先存入指令被淘汰下面是否还有指令 结束得出命中率图2.2 OPT算法流程图四、小结本次课程设计目的是通过请求页式管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
操作系统实验4-请求分页存储管理模拟实验
实验四请求分页存储管理模拟实验一：实验目的通过对页面、页表、地址转换和页面置换过程的模拟，加深对请求分页存储管理系统的原理和实现技术的理解。
二：实验内容假设每个页面可以存放10条指令，分配给进程的存储块数为4。
用C语言或Pascal语言模拟一进程的执行过程。
设该进程共有320条指令，地址空间为32个页面，运行前所有页面均没有调入内存。
模拟运行时，如果所访问的指令已经在内存，则显示其物理地址，并转下一条指令；如果所访问的指令还未装入内存，则发生缺页，此时需要记录缺页产生次数，并将相应页面调入内存，如果4个内存块已满，则需要进行页面置换。
最后显示其物理地址，并转下一条指令。
在所有指令执行完毕后，显示进程运行过程中的缺页次数和缺页率。
页面置换算法：分别采用OPT、FIFO、LRU三种算法。
进程中的指令访问次序按如下原则生成：50%的指令是顺序执行的。
25%的指令是均匀分布在低地址部分。
25%的指令是均匀分布在高地址部分。
三：实验类别分页存储管理四：实验类型模拟实验五：主要仪器计算机六：结果OPT:LRU:FIFO:七：程序# include<stdio.h># include<stdlib.h># include<conio.h># define blocknum 4//页面尺寸大小int m; //程序计数器，用来记录按次序执行的指令对应的页号static int num[320]; //用来存储320条指令typedef struct BLOCK //声明一种新类型--物理块类型{int pagenum; //页号int accessed; //访问量，其值表示多久未被访问}BLOCK;BLOCK block[blocknum]; //定义一大小为8的物理块数组void init() //程序初始化函数,对block初始化{for(int i=0;i<blocknum;i++){block[i].pagenum=-1;block[i].accessed=0;m=0;}}int pageExist(int curpage)//查找物理块中页面是否存在,寻找该页面curpage是否在内存块block中，若在，返回块号{for(int i=0; i<blocknum; i++){if(block[i].pagenum == curpage )return i; //在内存块block中，返回块号}return -1;}int findSpace()//查找是否有空闲物理块,寻找空闲块block，返回其块号{for(int i=0;i<blocknum;i++){if(block[i].pagenum==-1)return i; //找到了空闲的block，返回块号}return -1;}int findReplace()//查找应予置换的页面{int pos = 0;for(int i=0;i<blocknum;i++){if(block[i].accessed > block[pos].accessed)pos = i; //找到应该置换页面，返回BLOCK中位置}return pos;void display()//显示物理块中的页面号{for(int i=0; i<blocknum; i++){if(block[i].pagenum != -1){printf(" %02d ",block[i].pagenum);printf("%p |",&block[i].pagenum);}}printf("\n");}void randam()//产生320条随机数,显示并存储到num[320]{int flag=0;printf("请为一进程输入起始执行指令的序号(0~320):\n");scanf("%d",&m);//用户决定的起始执行指令printf("******进程中指令访问次序如下：(由随机数产生)*******\n");for(int i=0;i<320;i++){//进程中的320条指令访问次序的生成num[i]=m;//当前执行的指令数，if(flag%2==0)m=++m%320;//顺序执行下一条指令if(flag==1)m=rand()%(m-1);//通过随机数，跳转到低地址部分[0，m-1]的一条指令处，设其序号为m1if(flag==3)m=m+1+(rand()%(320-(m+1)));//通过随机数，跳转到高地址部分[m1+2，319]的一条指令处，设其序号为m2flag=++flag%4;printf(" %03d",num[i]);//输出格式：3位数if((i+1)%10==0) //控制换行,每个页面可以存放10条指令，共32个页面printf("\n");}}void pagestring() //显示调用的页面序列,求出此进程按次序执行的各指令所在的页面号并显示输出{for(int i=0;i<320;i++){printf(" %02d",num[i]/10);//输出格式：2位数if((i+1)%10==0)//控制换行,每个页面可以存放10条指令，共32个页面printf("\n");}}void OPT() //最佳替换算法{int n=0;//记录缺页次数int exist,space,position;int curpage;//当前指令的页面号for(int i=0;i<320;i++){m=num[i];curpage=m/10;exist=pageExist(curpage);if(exist==-1){ //当前指令的页面号不在物理块中space=findSpace();if(space != -1){ //当前存在空闲的物理块block[space].pagenum = curpage; //将此页面调入内存display();//显示物理块中的页面号n++;//缺页次数+1}else{ //当前不存在空闲的物理块，需要进行页面置换for(int k=0;k<blocknum;k++){for(int j=i;j<320;j++){//找到在最长（未来）时间内不再被访问的页面if(block[k].pagenum!= num[j]/10){block[k].accessed = 1000;} //将来不会被访问，设置为一个很大数else{ //将来会被访问，访问量设为jblock[k].accessed = j;break;}}}position = findReplace();//找到被置换的页面 ,淘汰block[position].pagenum = curpage;// 将新页面调入display();n++; //缺页次数+1}}}printf("缺页次数:%d\n",n);printf("缺页率:%f%%\n",(n/320.0)*100);}void LRU() //最近最久未使用算法{int n=0;//记录缺页次数int exist,space,position ;int curpage;//当前指令的页面号for(int i=0;i<320;i++){m=num[i];curpage=m/10;exist = pageExist(curpage);if(exist==-1){ //当前指令的页面号不在物理块中space = findSpace();if(space != -1){ //当前存在空闲的物理块block[space].pagenum = curpage; //将此页面调入内存display();//显示物理块中的页面号n++;//缺页次数+1}else{ //当前不存在空闲的物理块，需要进行页面置换position = findReplace();block[position].pagenum = curpage;display();n++; //缺页次数+1}}elseblock[exist].accessed = -1;//恢复存在的并刚访问过的BLOCK中页面accessed为-1for(int j=0; j<blocknum; j++){//其余的accessed++block[j].accessed++;}}printf("缺页次数:%d\n",n);printf("缺页率:%f%%\n",(n/320.0)*100);}void FIFO(){int n=0;//记录缺页次数int exist,space,position ;int curpage;//当前指令的页面号int blockpointer=-1;for(int i=0;i<320;i++){m=num[i];curpage=m/10;exist = pageExist(curpage);if(exist==-1){ //当前指令的页面号不在物理块中space = findSpace();if(space != -1){ //当前存在空闲的物理块blockpointer++;block[space].pagenum=curpage; //将此页面调入内存n++;//缺页次数+1display();//显示物理块中的页面号}else{ // 没有空闲物理块，进行置换position = (++blockpointer)%4;block[position].pagenum = curpage; //将此页面调入内存n++;display();}}}printf("缺页次数:%d\n",n);printf("缺页率:%f%%\n",(n/320.0)*100);}void main(){int choice;printf("************请求分页存储管理模拟系统*************\n");randam();printf("************此进程的页面调用序列如下**************\n");pagestring();while(choice != 4){printf("********1:OPT 2:LRU 3:FIFO 4:退出*********\n");printf("请选择一种页面置换算法:");scanf("%d",&choice);init();switch(choice){case 1:printf("最佳置换算法OPT:\n");printf("页面号物理地址页面号物理地址页面号物理地址页面号物理地址\n");OPT();break;case 2:printf("最近最久未使用置换算法LRU:\n");printf("页面号物理地址页面号物理地址页面号物理地址页面号物理地址\n");LRU();break;case 3:printf("先进先出置换算法FIFO:\n");printf("页面号物理地址页面号物理地址页面号物理地址页面号物理地址\n");FIFO();break;}}}。
计算机操作系统分析
将该段释放，包括撤销该进程段表中共享段所
对应的表项，以及执行count:=count - 1操作。
若结果为0，则需由系统回收该共享段的物理内
存，取消段表中的对应表项；否则，则只是取 消调用者进程在共享段表中的有关记录。
3. 分段保护 Segment Protection
• 之后，当又有其它进程要调用该共享段时，只需 在调用进程的段表中，增加一表项，填入该共享 段的物理地址；同时在共享段的段表中，填上进 程名、存取控制等，执行count:=count+1操作。
2. 共享段的分配与回收 Allocation and Return of Shared Segment
2) 共享段的回收
• 一个好的页面调度算法，应具有较低的页面更换频
率。从理论上讲，应将那些以后不再访问的页面换 出，或把那些在较长时间内不会再访问的页面调出。
4.7.1 最佳置换算法和先进先出算法 OPT and FIFO Algorithm
1. 最佳(Optimal)置换算法 OPT算法所选择的被淘汰页面，将是永久不
3. 造成动态分区分配方式浪费内存空间的主要原
因是什么？它可以通过什么办法加以解决。－
－紧凑或拼接
4. 什么是对换？对换的分类：
– 整体对换或进程对换； – 部分对换或页面对换（分段对换）
5. 分页系统是如何将地址空间中的作业划分成若 干个页，它又是如何进行内存分配的？
6. 分页系统的地址转换。掌握分页系统逻辑地址 的结构，为了进行逻辑地址到物理地址的转换， 分页系统必须为每个作业配置什么样的数据结 构并提供哪些硬件支持，为什么引进快表可以 加快分页系统存取指令和数据的速度。 7. 分段存储管理方式。了解由分页发展为分段， 并进一步发展为段页式存储管理方式的主要推 动力是什么，分段和段页式系统是如何管理作 业的地址空间和内存空间的，它们的地址变换 是如何完成的，并应注意对分段系统和分页系 统的比较。
虚拟存储器的基本概念
19
请求分页虚存地址转换过程(2)
逻辑地址
无登记
有登记
查快表
在辅存
在主存 查页表
形成绝对地址
发缺页中断
登记入快表
继续执行指令 硬件
保护现场 无
主存有空闲块
有
装入所需页面
调整页表和 主存分配表
恢复现场
重新执行 被中断指令
操作系统
未修改
选择调出页面 该页是否修改
已修改
把该页写回 辅存相应位置
20
4.6.2页面分配策略和分配算法
• 如果页面替换算法的作用范围局限于本进程， 称为局部页面替换算法,它实际上需要为每个 进程分配固定的页框。
• 置换范围 –全局 与 局部
三种组合：固定 + 局部 可变 + 全局 可变 + 局部
23
固定分配和局部替换策略配合使用
•进程分得的页框数不变，发生缺页中 断，只能从进程的页面中选页替换，保 证进程的页框总数不变。 •策略难点：应给每个进程分配多少页 框?给少了,缺页中断率高;给多了,使内 存中能同时执行的进程数减少，进而造 成处理器和其它设备空闲。
• 2虚拟存储器的容量与主存的实际大小没 有直接的关系，而是由主存与辅存的容量 之和所确定。
13
虚拟存储管理主要采用以下技 术实现：
•分页请求虚拟存储管理 •分段请求虚拟存储管理 •段页式请求虚拟存储管理
14
一. 请求式分页存储管理
请求式分页也称虚拟页式存储管理 与纯分页存储管理不同，请求式分
页管理系统在进程开始运行之前，不是 装入全部页面，而是装入一个或零个页 面，之后根据进程运行的需要，动态装 入其它页面；当内存空间已满，而又需 要装入新的页面时，则根据某种算法淘 汰某个页面，以便装入新的页面
操作系统实验3--请求分页式存储管理
请求分页式存储管理一、问题描述设计一个请求页式存储管理方案，为简单起见。
页面淘汰算法采用FIFO页面淘汰算法，并且在淘汰一页时，只将该页在页表中修改状态位。
而不再判断它是否被改写过，也不将它写回到辅存。
二、基本要求页面尺寸1K，输入进程大小（例如5300bytes），对页表进行初始化页表结构如下：系统为进程分配：任意输入一个需要访问的指令地址流（例如：3635、3642、1140、0087、1700、5200、4355，输入负数结束），打印页表情况。
每访问一个地址时，首先要计算该地址所在的页的页号，然后查页表，判断该页是否在主存——如果该页已在主存，则打印页表情况；如果该页不在主存且页框未满（查空闲块表，找到空闲块），则调入该页并修改页表，打印页表情况；如果该页不在主存且页框已满，则按FIFO页面淘汰算法淘汰一页后调入所需的页，修改页表，打印页表情况。
存储管理算法的流程图见下页。
三、实验要求完成实验内容并写出实验报告，报告应具有以下内容：1、实验目的。
2、实验内容。
3、程序及运行情况。
4、实验过程中出现的问题及解决方法。
#include<stdio.h>#include<stdlib.h>int PUB[20][3];int ABC[3][2]={{0,1},{1,1},{2,1}};//物理块int key=0;void output(int size){//打印int i,j;printf("页号\t\t物理块号\t\t状态位\n\n");for(i=0;i<size;i++){printf(" %d\t\t%d\t\t\t%d\n\n",PUB[i][0],PUB[i][1],PUB[i][2]);}printf("物理块号\t\t是否空闲\n\n");for(i=0;i<3;i++){printf(" %d\t\t\t%d\n\n",ABC[i][0],ABC[i][1]);}}void main(){int size;int i,j;int address=0;int select=0;printf("请输入进程大小\n");scanf("%d",&size);if(size<=0 || size>20000){printf("进程大小超出范围\n");exit(0);}size%1000==0 ? size=size/1000 : size=size/1000+1;for(i=0;i<size;i++){PUB[i][0]=i; //页号PUB[i][1]=0; //物理块号PUB[i][2]=0; //状态位}output(size);while(1){printf("输入指令地址\n");scanf("%d",&address);if(address<0 || address>20000){printf("地址超出范围\n");exit(0);}address%1000==0 ? address=address/1000 : address=address/1000;if(PUB[address][2]==0) //不在主存{if(ABC[2][1]==0) //满了{printf("满了\n");if(select!=address) key++;for(i=0;i<size;i++){if(PUB[i][1]==key){PUB[i][1]=0;PUB[i][2]=0;}}PUB[address][1]=key;PUB[address][2]=1;key++;if(key>3) key=1;}if(ABC[2][1]==1) //没满{printf("没满\n");for(i=0;i<3;i++){if(ABC[i][1]==1){ABC[i][1]=0;PUB[address][1]=i+1;PUB[address][2]=1;break;}}}output(size);}else{printf("该页已在内存\n");output(size);}select=address;}}。
简述请求分页存储管理方式
简述请求分页存储管理方式
请求分页存储管理方式是一种将主存储器划分为等大小的块，每个块称为一页的管理方式。
在此方式下，每个进程所需的存储空间被划分为多个大小相等的页，每一页都有一个唯一的页号。
当进程请求存储空间时，操作系统会根据其空间需求来分配一页或多页的空间。
此管理方式的主要优点是可有效地利用主存储器，因为在这种情况下，内存中只有进程所需的部分被加载。
这意味着，对于较大的程序，它们不需要一次性将整个程序加载到内存中，而只需要加载所需的部分。
因此，更多的程序可以同时运行，从而提高了系统的效率。
此外，请求分页存储管理方式还可以提高系统的灵活性。
进程可以根据其存储需求请求不同数量的页面，这意味着，系统可以动态地分配存储空间，以满足进程的需求。
总的来说，请求分页存储管理方式是一种高效、可扩展的管理方式，它可以提高系统的效率和灵活性，使多个进程可以同时运行，从而提高系统的性能。
- 1 -。
若依管理系统源码分析-分页的实现以及post请求时的分页
若依管理系统源码分析-分页的实现以及post请求时的分页场景官⽅⽰例分页实现前端调⽤实现// ⼀般在查询参数中定义分页变量queryParams: {pageNum: 1,pageSize: 10},// 页⾯添加分页组件，传⼊分页变量<paginationv-show="total>0":total="total":page.sync="queryParams.pageNum":limit.sync="queryParams.pageSize"@pagination="getList"/>// 调⽤后台⽅法，传⼊参数获取结果listUser(this.queryParams).then(response => {erList = response.rows;this.total = response.total;});后台逻辑实现@PostMapping("/list")@ResponseBodypublic TableDataInfo list(User user){startPage(); // 此⽅法配合前端完成⾃动分页List<User> list = userService.selectUserList(user);return getDataTable(list);}注：实现使⽤若依⾃动⽣成的代码前端使⽤pagination控件，基于Bootstrap的轻量级表格插件 BootstrapTable<paginationv-show="total>0":total="total":page.sync="queryParams.pageNum":limit.sync="queryParams.pageSize"@pagination="getList"/>其中pageNum代表当前页号，即第⼏页，pageSize代表每页显⽰的条数。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
48K B
64K B
图 存储容量与缺页中断次数的关系
4．页面置换算法性能 三个参数：
页面走向：每个作业的虚页调入实存的顺序，称为页面轨迹，
或页面走向，用P表示。 主存容量：是指分配给作业的主存块数，M表示。 置换算法：包括FIFO，LRU等
P 行表示页面走向，M 行表示在主存中的页面号，其中带有+ 的表示新调入 页面，在M行的各列按调入的顺序排列，带有圆圈的数字表示下一时刻 将被淘汰页面，F行表示是否引起缺页中断，带+号的表示引起缺页中断。
实存管理
• 具有整体性、驻留性及连续性三种特性的 存储器管理方法，叫实存管理。我们学习 过的无论是分区管理，分页管理，或分段 管理，还是段页式管理，都属于实存管理。 • 实存管理的所谓整体性是指一个作业的全 部实体在执行之前必须被整个地装入内存， 也就是说，如果一个作业的逻辑地址空间 大于内存的用户区时就不能执行。
虚页号 辅存地址
③ 新调入的页面装入何处？
实存中有空闲实页，直接将其装入。 空闲已满，则必须淘汰（页面置换算法）实存中的某一页。 被淘汰的页，以后可能还要用，是否需要写回辅存， 这取决于该页进入实存后是否被修改，如未被修改，因辅 存上已有副本则不必写回辅存。否则，要重新写回辅存。 因此页表中还可以增加一个“修改位”，以反映该页是否 已被修改过。 为了便于系统管理页面置换，增加“引用位”，表示该 页最近是否被访问过。
虚拟存储器的概念 P61
• 虚拟存储技术的基本思想是利用大容量的外存来扩
充内存，产生一个比有限的实际内存空间大得多的、
逻辑的虚拟内存空间，以有效支持多道程序设计
的实现和大型程序运行的需要，增强系统的处理能 力。
•
请求分页系统支持虚拟存储技术
请求分页存储管理
• 名词
1. 作业的逻辑地址空间划分的页，称为 虚页 2. 主存称为实存 3. 实存中的块称为实页
• 更加有利于多道程序的运行， 从而提高了系统 效率；
–
局部化程度随程序而异，一般来说，总希望编制 的程序具有较高的局部化程度。这样，程序执行 时可经常集中在几个页面上进行访问，以减少缺 页中断的次数。
② 页面的大小
页面大小应根据实际情况来确定，它和计算机的性能 以及用户的要求都有关系。
• 页面大，页表小，占用空间小，缺页中断次数少，但换 页时间长，页内碎片也大，浪费空间 • 页面小时，正好相反
b)
c)
②
当程序要访问的某页不在内存时，如何发现 这种缺页情况？发现后应如何处理？
地址变换机构检测到虚页的状态为1，由硬件产生缺页中断，转去中断处理
③ 所需的页面从何处装入？
在请求分页管理系统中，当一个作业完成编译 链接后，所形成的装配模块通常以文件形式存入作 为辅存的磁盘上，当该页需要装入实存时，就从磁 盘上调进来。为此，需建立一个作业的辅助页表， 也称为外页表。
页面置换算法/淘汰算法
• • • • 先进先出算法(FIFO)
– 淘汰驻留主存时间最长的页面
最近最久未用置换算法(LRU)
– 淘汰在最近一段时间最久未用的页面
最近最不常用算法 最近未使用算法
1. 先进先出算法（FIFO算法）
• 这种算法的基本思想是：总是先淘汰那些驻留 在内存时间最长的页面，即先进入内存的页面先被 置换掉。 •理由是：最先进入内存的页面不再被访问的可能 性最大。
成立。即对于任何时刻t(t=1, 2, …, 12),G(P, M, t)所选中的页
号必定包含在G(P, M+1, t)之中。这种关系说明了增加主存
容量不会增加缺页中断次数，然而对FIFO算法， 此关系并 不成立。
请求分页存储管理方案的评价
• 它提供了大容量的多个虚拟存储器， 作业地址 • 更有效地利用了主存，一个作业的地址空间不必 全部同时都装入主存， 只装入其必要部分，其 它部分根据请求装入， 或者根本就不装入(如错 误处理程序等)
图 缺 页 中 断 的 发 生 及 其 处 理
抖动/ 系统颠簸
软 件
复 制 到 辅 存
取 出 保 存 的 页 号 找 出 磁 盘 地 址 入 页 修 改 PM T M BT表 重 新 执 行 被 中 断 的 指 令
抖动/系统颠簸
出页：将某一页从实存移到辅存
入页：将某一页从辅存调入实存
这种反复进行入页和出页的现象称为“抖动/系统颠簸”
•
–
程序的局部化程度包括时间局部化和空间局部化
时间局部化是指一旦某个位置----数据或指令----被访 问了，它常常很快又要再次被访问。这可通过循环、经 常用到的变量和子程序等程序结构来实现。 空间局部化是指一旦某个位置被访问到，那么它附近的 位置很快也要用到。这可以尽量采用顺序的指令列、线 形的数据结构来实现。
扩充后的PMT表
虚页号 主存块号 改变位 引用位 状态位 辅存地址
0/1 主存块号 0/1 1该页已被 0/1 修改过 1最近已被 0在内存 访问过 0该页未被 1不在内存 修改
辅助页表
虚页号 辅存地址 保护信息
执 行 一 条 指 令 形 成 有 效 地 址 计 算 页 号 硬 件 该 页 在 实 存 吗 ？ N 缺 页 中 断 入 口 出 页 有 空 闲 的 实 页 码 ？ Y N 修 改 PM T M BT Y C = 1？ N Y 取 数 据 完 成 该 指 令 取 下 一 条 指 令
• 驻留性是指作业一旦进入内存便一直驻留 在内存区直到运行完毕。 • 连续性，顾名思义，是指给作业分配的一 片连续的内存空间。 • 整体性、驻留性及连续性这三种特性不利 于内存空间的有效利用。
虚拟存储器
• 虚拟存储器（Virtual Memory），简称虚存， 是指对内存的虚拟，一种实际并不存在的 内存空间，包括一级存储器概念和作业地 址空间概念。虚拟并不是无限的，取决于 机器的CPU地址结构，虚存容量不能大于 外存容量。
缺页中断次数F=10， 缺页率f=10/12=83%。
例 4 设M=4，其余同例 3，则缺页中断次数和 缺页率？
表4LRU性能分析例(M=4)
3
4
由表 3， 表 4 设G(P, M, t)表示当页面走向为P，主存容量为M，在时 刻t的页面集合，对于LRU算法，存在如下关系，即
G ( P , M , t ) G ( P , M 1 , t )
2．最近最久未使用页面置换算法（ Least Recently Used/ LRU算法）
•这种算法的基本思想是，如果某一页被访问了，那么它 很可能马上又被访问；反之，如果某一页很长时间没有被 访问，那么最近也不太可能会被访问。这种算法考虑了程 序设计的局部性原理。其实质是，当需要置换一页时，选 择在最近一段时间最久未使用的页面予以淘汰。
请求分页管理
• 请求分页管理是动态分页管理，是在静态分页管 理基础上发展而来的。在简单分页管理中，如果 作业所要求的页面数比内存空闲的块数多，则该 作业不能装入运行。在虚拟存储器技术的支持下， 可以进行请求分页管理。 • 那么请求分页管理的基本思想是什么？作业要访 问的页面不在内存时，该如何处理？如何知道哪 些页面在内存，哪些不在？如何决定把作业的哪 些页面留在内存中呢？将虚页调入内存时，没有 空闲块又怎么处理？ • 在虚拟存储系统中，将对逻辑空间和物理空间的 考虑截然分开，逻辑空间的容量由系统提供的有 效地址长度决定。
1. 请求调入及缺页中断处理 2. 淘汰算法 3. 抖动与工作集
请求分页存储管理铺垫
1. 作业在运行期间的各个阶段，多数作业只使用全 部地址空间的一部分。例如用户编制的出错处理 子程序，在作业正常运行情况下不会执行这些程 序，没有必要把它们调入内存。即程序中往往会 有一些彼此互斥的部分不是每次运行时都能执行 到。 2. 程序的局部性。顺序执行的指令和线性结构的数 据(如数组)。它们通常被限定在某一连续区域。一 旦某一位置被访问后，那么它附近的位置很快也 会被访问。
例 1 设页面走向为P=4, 3, 2, 1, 4, 3, 5, 4, 3, 2, 1, 5，主存容量 M=3 ，置换算法采用 FIFO ，求访问过程中发生缺页中断的 次数和缺页率？假设开始时，主存未装入任何块 。 表1 FIFO性能分析例(M=3)
缺页中断次数F=9 缺页率f=9/12=75%
例 2 设M=4，其余同例 1。则缺页中断次数和缺页率？ 表2 FIFO性能分析例(M=4)
• 实现这种算法可通过周期性地对“引用位”进行检查， 并利用它来记录一页面自上次被访问以来所经历的时间t， 淘汰时选择t最大的页面。 •不太实用
性能分析
为了尽可能地减少缺页中断的次数，应从
① 程序设计的质量 ② 页面的大小 ③ 主存的容量 ④ 页面置换算法 等几方面来考虑。
①
程序设计的质量(主要指程序的局部化程度)
• 请求分页管理就能实现这种虚存空间，基本方法是在分页管 理的基础上，在作业开始执行前，只装入作业的一部分页面 到内存，其它的页面在作业执行过程中根据需要，动态地从 辅存装入内存。当内存块已经占满时，再根据某种策略交换 出部分页面到辅存。 • 根据作业的执行情况装入作业的部分实体，显然节省了内存 空间。 • 请求分页管理和分页管理的数据结构、地址映射和存储保护、 存储分配与回收等都类似，但请求分页管理的实现过程复杂 很多，需要由硬件和软件的相互配合才能完成。
③ 主存的容量 一个作业的执行所产生缺页的次数是存放页面的实际存 储容量的函数。当存储容量达到某一程度时，缺页中断 的次数的减少就不明显了。 试验分析表明：对所有程序来说，要使之有效地工作， 它在主存中的页面数不低于它的总页面数的一半。
缺 页 次 数F 9000 8000 7000 6000 5000 4000 3000 2000 1000 0 16K B 32K B M 80K B 96K B 112K B 主 存 大 小 M 24 K B 32 K B 48 K B 64 K B 80 K B 96 K B 112 K B 128 K B 160 K B 192 K B F 9321 5126 2456 1295 696 441 329 271 144 62