UCB CS61c 组成原理中文笔记（七）
P42：Lecture 32： VM I： Intro - 这样好__ - BV1s7421T7XR
我们要开始放幻灯片了，有有一些，幻灯片中的一些缓慢，但他们很快就会被张贴出来。
所以今天我们要多谈谈这台电脑，我们一直在谈论的，丹一直在说什么，在过去的几周里，这种访问东西的高速方式不需要，一路走到记忆中，我们也一直在讨论线程，所以你有一些程序的想法，一些过程。
你想利用你拥有的多个核心，好啦，这就是所谓的多线程或多处理，但让我们后退一点，谈谈计算机。
好啦，那么我这么说是什么意思，让我们把老派的C61一幕，这里的机器结构图，你会看到我强调了一些事情，记忆就是其中之一，我们将在这个单元中更多地讨论记忆，但我们也要谈谈这件事，称为i o系统，我代表输入。
永远代表输出，然后我们要谈谈，假设某个操作系统，Mac OS X Linux，所有这些事情，你会发现它确实，超出61 C的范围，所以我们要把这些部分，这对我们正在谈论的事情很重要。
您现在可以使用一个62操作系统了解更多信息。
如果我们看一下新的学校机器结构图，我们在哪里，我试着把它放进去一点，这里没有真正的盒子，但我试着把这个小盒子放在这里，我们将讨论并行程序，好啦，所以你可以运行多个程序的想法。
让我们说幻灯片松弛或电子邮件或其他东西都在同一时间，在一台计算机上，在单个处理器上，这就是我们将在本单元讨论的内容。
到目前为止我们在哪里，我在项目方面概述了一点，项目四不在这里，不过，请你再忍耐一下，项目一是C程序的思想，事实上，我确实把项目给了一个同行，因为它是关于线程C程序的，你有一个单一的程序的想法。
它完成了一件事，然后也许你可以多线程，为了让它更快地完成这件事，我们讨论的第二件事是风险五，因此，一个互联网指令集体系结构和ISA，这是项目二，所以我们写风险五代码的想法，所以C代码正在编译成汇编。
然后程序集编译成机器代码，然后我们有项目三，构建自己的CPU，什么是CPU，记住只是那个处理器，它是真正做你想做的事情的东西，它与两个项目有什么相互作用，一个缓存，如果它存在，所以这有点像。
那是一个很容易得到你所有的，最近使用的数据，如果它不在你的缓存里，然后你去回忆，稍微远一点，你知道储藏室可能在校园里，然后记忆在遥远的萨克拉门托。
在这一点上你可能会想，你就像等等，坚持住，好啦，所以这在金星的环境中是合理的，我知道如果我发射金星运行一个程序，它会运行，然后它会简单地停止，但我的笔记本电脑看起来完全不同，第一名。
但假设左边是我的笔记本电脑，好啦，一号有视觉元素，好啦，不仅仅是代码，但你有一个屏幕，你有键盘，你有存储，这就是我们所说的输入输出，注意存储也在这个桶中，我一会儿要讲一点。
你的笔记本电脑做的第二件事是金星。
至少在我们的迭代中，但它不能同时运行多个程序，然后有这种，有一种叫做操作系统的软件，它将所有这些程序联系和管理在一起，好啦，所以我们要稍微谈谈操作系统是如何，还有哪些资源需要在所有这些项目之间共享。
现在你可能有点想知道，好啦，为什么输入输出，比如磁盘在哪里，让我们看看另一台电脑，那是带屏幕和键盘的笔记本电脑，所有这些事情，让我们来看看覆盆子圆周率，覆盆子圆周率是一台超级便宜的电脑，但它本身。
如果你没有在所有不同的端口上焊接，现在一块主板要三块五，如果你在上面焊接东西，然后你实际上可以插入东西，你可以插上显示器，你可以插入所有这些东西，然后运行像Linux或其他类似的东西。
那么让我们看看这里的主板上有什么，首先，我们从CPU和缓存开始，现在有个有趣的迹象，你见过美元符号，也许如果你没有，你的机会来了，美元符号是现金的简称，因为现金，听起来像是钱，就像现金，反正。
所以这里有个美元符号，所以你，如果你看到，如果你现在看到那个图标，你就知道它是缓存，好啦，所以这里有一堆缓存，离中央处理器很近，这里的第二件事是记忆，我们会谈谈这个，但是请注意，它与CPU是完全分开的。
它还在同一块板上，但它就像一个单独的东西，焊接在，这里还有一些其他的东西，许多不同的i o设备都是通过这种端口焊接的，好啦，例如，我们这里有一个USB端口，USB A端口，我们有一个网络，我喜欢。
假设一个以太网端口，我们有无线WiFi，我的东西是焊接在上面的，然后我们有一个迷你HDMI端口，可以连接到屏幕，然后还有第三个，这里还有最后一件事，它是一个存储输入输出，这是一张微型SD卡。
你只是扑通一声，好啦，所以这就是我的意思，当我说存储也是一种输入输出设备时，因为它通常是通过某种端口连接的，所以如果你有过外接硬盘之类的东西，这就是我们所考虑的存储方式，但即使在笔记本电脑里，例如。
我的笔记本电脑有256千兆字节的存储空间，那和公羊不一样，也就是8G的内存，在我的情况下，或者有时是千兆字节的RAM，这意味着Chrome经常崩溃，不过，我们可以以后再谈，那么六十一怎么样。
覆盆子皮怎么样，如果你对更多感兴趣，我们实际上并没有涵盖所有的概念，但你可以，你可以用覆盆子圆周率覆盖61 C中的所有概念，所以如果你对这个感兴趣，你绝对可以去下载这本书，真的很酷。
你可以买你便宜的覆盆子圆周率，或者你可以问，我们就能想出办法，也许吧，请一定要看看，这将是一个好时机，这将是一个很好的冬季项目，只是在上面建造你自己的电脑，在这个非常小的，极小装置，那么我们在哪里。
这是我们看到的原图，但这次我们要谈的是记忆，I，O，设备，以及如何管理共享资源集，在许多几乎同时运行的程序中，好啦。
所以这就是我们今天所处的位置，在接下来的两节课中，我将介绍操作系统，但又像，我们有整整一学期16周的时间来学习操作系统，我们只是要涵盖基本的，这样你就知道它是如何相互作用的，以及它如何允许您管理程序。
所以让我们来谈谈一个，首先是上下文切换的一个高级想法。
我要谈谈操作系统，所以对你们很多人来说，你可能会认为操作系统就像可怕的东西，这就像，就像一个神奇的东西，不知何故运行着所有这些东西，原来操作系统只是软件，这是保密软件。
所以它可以运行其他用户程序无法运行的特殊功能，但这只是软件，让我们来看看其中一个，呃，这个小代码库很酷。
让我们看看这里有没有，没有，好啦，把它移到屏幕上，我要试着放大。
但我之前试过了，但它并没有真正起作用，所以让我们看看，如果你看到这里，这是呃，在数百万行代码中，你可以看到在一百个，好啦，所以第一组第一组酒吧，这里的灰色条是一百万行代码和下面的一切。
这是几十万行的帖子，你可以看到一个iPhone游戏应用程序很漂亮，这是一个很小的问题，零一所以就像，可能有一万行左右的代码，然后航天飞机实际上也很小，那很酷。
现在我们把这个由数百万条线组成的巨大的灰色长条映射到瘦骨嶙峋的灰色长条中，现在是一百万行代码，在第二组图表中，当我们向下滚动时，你可以看到，突然我们得到一些操作系统代码，所以这是Linux内核两点两点。
一个非常早期的版本，虚幻引擎也是两百万行代码窗口，在1992年，两千分之一的三点是两点，500万行代码，让我们继续向下滚动，哦Xbox，高清，DVD播放机，是呀，那个年龄很好，继续走窗户。
在1993年安卓操作系统，所以这是一个移动设备操作系统，现在有1200万行代码，我的续集因为某种原因是巨大的，很刺激，微软办公室，它只是不断增长脸书，好啦，不过，好吧，这就是我们想去的地方。
看看2014年的Mac OS Tiger，随便啦，这个号码在上面，八千六百万行代码，所以这是操作系统的大小，好的结果是你知道如果你向下滚动一点，谷歌来了，反正，所以你可以更详细地了解一下，如果你愿意。
如果你，如果你愿意，让我们回到幻灯片，当我试图把这个拿起来的时候，斗斗。
是啊，是啊，我们做到了，下面是操作系统的另一个视图，所以我们在之前的幻灯片上看到了Linux的早期版本，让我向你展示内核是如何，它是操作系统的核心部分，在数百万行代码中增长，所以这里的版本。
这些都是不同的版本，然后现在，随着我们越来越接近最新的版本，你可以看到它变成了数千万行代码，所以这可能是在你的机器上运行的最重要的软件，它也可能是软件中最大的一部分，当您决定安装操作系统时。
它需要几千兆字节的内存或存储空间，那是因为它只是大量的代码。
所以我告诉过你这很重要，我们可以看到，通过这里代码库的大小，但它又是怎么做的呢，这是系列演讲的第一课，在这里我们将讨论一点操作系统，以下是它所做的想法，好啦，第一件事是它是如此重要，以至于它有效地。
开始的第一件事，当计算机启动时运行的第一个软件，它在那个时候做什么，操作系统启动各种服务，我所说的服务是什么意思，文件系统，网络堆叠，所以像以太网这样的东西，WiFi卡，所有这些类型的事情，键盘，好啦。
所以这个t y代表键盘，至少在我们这里的语言中是这样，现在操作系统已经启动了所有的服务，它还能做什么，它提供了所有这些i之间的交互，o计算机上运行的设备和程序，所以说，例如，如果有储藏室。
如果有你知道的以太网卡，全部或像USBA，也许有什么东西插在那里，操作系统使用这些类似于硬件特定的驱动程序来管理所有这些，你可以说，你可以在以后的课上学习。
但我们想强调的是，至少在接下来的两堂课左右，两三堂课，操作系统管理不同的程序，所以它是一个管理其他软件的软件，好啦，它实际上加载了，你还记得吗，叫它装载机，其中的一部分，让我们，是啊，是啊。
最后一个电话，是装载机，是那个跑腿的，所以它告诉它，它告诉CPU下一个运行哪个东西，经理们会说，好啦，现在呢，CPU，现在您实际上应该运行这个程序，这里有几个关键术语我们要考虑，其中之一就是隔离，好啦。
因此，操作系统提供的是每个进程感觉像，它是孤立的，所以每个过程都感觉它可以控制所有不同的资源，记忆，所有这些可用的东西，通过这样做，虽然，即使每个过程感觉都是孤立的，它能控制一切，秘密发生了什么。
同时运行的，或同时运行的进程，例如内存，今天我们要谈很多关于记忆的事，第二个，伊诺，设备磁盘，网络，所有这些类型的事情，它甚至还可以分享时间，所以我们从记忆的角度来讨论资源，它也做时间共享。
操作系统管理这些东西，我这么说是什么意思，让我们假设您有一个CPU，为了在计算机上运行多个进程，这些进程需要以某种方式使用相同的CPU，如果CPU只有一个时钟，就像你知道的，只有一个管道。
然后操作系统负责分时，所有这些不同程序之间的CPU，好啦，所以资源共享和时间共享是操作系统所做的，但是从过程来看，它是一个独立运行的运行程序，这就是我们今天要关注的，但是明天我们要去。
我们不是明天星期三，我们将讨论操作系统的其他方面，好啦，我们真的要把重点放在内存和资源共享组件上，关于同时运行多个程序的另一个注意事项，这就是我们所说的多编程，不要与多处理混淆。
我想当我第一次知道这一点时，我很困惑，所以多处理就是当有多个CPU，多个处理器，您可以运行，假设多个线程或东西可以在不同的毛孔上同时运行，多编程，这就是我们今天要讨论的，东西可以同时运行。
在同一单核上引用未引用，好吧，为什么我又同时加了引号，CPU一次只能像一件事一样运行。
因为这条管道，我是说，好啦，它可以像指令级并行一样，但严格来说，它只能像一个单一的运行，就像不管怎样，让我们继续前进，报价，同时取消引用是从人类的角度出发的，当人类看到这些多个程序运行时，是啊，是啊。
他们可能像一个一样奔跑，一个在最初的十毫秒或一百毫秒内运行，一个在第二个10毫秒或100毫秒内运行，但是从人类的角度来看，这些东西大致是同时运行的，操作系统所做的是，它做这些非常快的事情。
这些非常快的东西叫做上下文切换，这是一个操作系统术语，这种上下文切换有效地完成了以下任务，它将当前进程状态保存在CPU上，例如，如果有一个程序计数器，就有寄存器，有一个特殊的状态寄存器。
所有这些都被保存在某个地方，然后下一个过程是将状态加载到CPU上，好啦，所以下一个过程是程序计数器和状态寄存器，所有这些东西都装满了，这里是这里是一点，虽然这个上下文切换，我们下次会更多地讨论。
这个上下文也不加载内存，所以它不会取代电流，在接下来的过程中，我有八个G的RAM，八格公羊或不管多少公羊，下一道工序需要，因为这个太贵了，我这么说是什么意思，让我们回到存储延迟分析。
我知道丹和我喜欢这张照片，所以我想把这张照片再贴一次，就像你知道的，在这里进行一场真正的荣耀之旅，所以我们有寄存器，那些真的离你很近，我们有校园，现金就在那里，现在的记忆是如果我们要去萨克拉门托。
所以想象一下在上下文切换上，假设你正在运行powerpoint，然后你想切换到你的互联网浏览器，谷歌Chrome什么的，想象一下，你不仅要切换CPU上的所有东西，超快的。
现在你必须把内存中的所有东西都换掉，所以你得一路跑到萨克拉门托，把所有东西都搬来搬去，然后一路回来，那就太慢了，那么这里的重点是什么呢，上下文切换只改变CPU中的内容，因此，关于进程如何共享内存。
需要有一些特殊的东西，即使他们不在运行，或者即使它们不是当前正在运行的进程，现在你可能会注意到这里有一个快速的符号，我可能会交替使用过程、应用程序和程序，这是故意的，从操作系统的角度来看。
我们考虑一个过程，单个程序，然后从产品中，你可以想象一个像Internet Explorer或谷歌Chrome之类的应用程序。
这些都是多个过程，好啦，但就目前而言，我们就假设每一个，如果每个应用程序都有一个进程，并且是一个程序，这就是我们在这节课里要做的，我们想知道我们是否有记忆，我们试图切换上下文，但我们不想总是切换内存。
所有可能大致同时运行的不同进程，好啦，所以这就是我们想去的地方，但首先，我认为了解一下。
内存和磁盘有什么区别，因为我想我们还没有完全讨论过这个问题，然而，我们在金字塔中从概念上看到了它，对你们中的一些人来说，如果你以前造过电脑，你大概知道我在说什么，但我只能假设，呃。
也许你们中的许多人还没有造出自己的电脑，所以我们现在要谈谈，我们现在在哪里。
在这个内存层次结构的金字塔中，我们算是垫底了，这里我们讨论的是主存，它实际上是随机存取存储器。
这里有一条绿色的线，让我们看看这东西今天能不能用。
是啊，是啊，它的工作原理，就是这个绿色的小条，这就是我们所说的记忆，我们在这节课中不是在谈论缓存。
然后在它的正下方是二级内存。
或者我们所说的存储或磁盘，所以你可以在这里看到，有固态记忆或闪存，这里还有磁碟，你还记得金字塔告诉我们，金字塔告诉我们，所有在更高层的东西实际上都是副本。
或者是下层的东西的子集，这仍然是真的，好啦，所以这就是我们在这里工作的想法，离磁盘非常非常远的东西，就像遥远的冥王星，会被复制到主存里，离这里只有萨克拉门托那么远，覆盆子派我们在哪里。
你可以想象下面的情况，我们有点像记忆，这里是芯片本身，但它与CPU是分开的，然后仓库，假设这是一张微型SD卡，它是一种输入输出设备，好啦，所以这有点像。
在这方面，呃，物理距离也是，让我们来谈谈这些项目。
就像你可能看到的一些术语一样，如果你去买一些电脑零件。
所以第一个是主存，你会听到我叫它Dram。
代表动态随机存取存储器，公羊大致做了什么，至少在统计方面，它是相当快的，所以只有10纳秒的时间，然后可能每一个连续的单词都快一点，每次加载一组单词中的每个轴，比如说六十四位，然后它还支持像脉冲加载。
这里是这里是这里的要点，也就是说，每千兆字节大约三美元，现在记住那个数字，为什么我有这个号码，一旦我们把它和s ram比对就知道了。
也就是缓存，但让我们来谈谈这个动态部分，因为你就像，好啦，DRAM就像记忆一样，记忆在改变吗，这里发生了什么事？动态实际上是指物理成分，就像这些DRAM芯片的物理创造，这里的动态是指L。
很多芯片上都有电容器，因此，通过或类似的表示位是通过某个晶体管实现的，可能是一个保持电荷或放电的电容器，对于那些学过物理7b或其他，呃，某种电子，M，电学和磁学类，你知道电容器，嗯。
随着时间的推移失去电荷，好啦，所以这里的动态部分是每隔一段时间，你只需要喜欢，再给它充电，这只是像DRAM现在必须做的事情，易挥发的部分，这是你会看到不稳定的东西，指的是DRAM需要恒定的电源。
从电容器的角度来看，这是有意义的，这没关系，电容器保持电荷，然后它不知何故输了，所以你总是要有一个恒定的电源，才能维持这样的电量，对比，这与SRAM或静态随机存取存储器，这是用来缓存的。
这里大致的区别是，静态意味着没有电容器，所以比特都是通过晶体管表示的，所以你不需要保持电荷，但它仍然不稳定，所以你仍然需要与权力有联系，而且要快得多，所以零点，五纳秒总是，但它更贵，而且密度也比较低。
好啦，所以DRAM的美妙之处在于你可以像，如果你只有一个电容器和一个晶体管，这比每个比特都有六到八个晶体管要小得多，都在行，好啦，这就是SRAM和DRAM之间的想法，这边有些照片，所以你可能又看到了。
如果你自己造了电脑，你见过这种暗淡的，这有点像笑话，当你添加更多的RAM时，或者喜欢下载更多RAM，你居然，你没有下载，在计算机中插入更多RAM，就是这个意思，但如果你要处理的是，比如说集成电路板。
就像笔记本电脑或微软的Surface，然后DRAM直接在芯片上，好啦，以及缓存，高速缓冲存储器，所有这些下一点，所以这是主存，超级超级快，有点贵，每千兆字节三美元，你可以想象它不能太大，现在呢。
让我们稍微谈谈磁盘，也就是我们所说的存储，也就是我们所说的二级记忆，这是不易挥发的，所以记住一个不稳定的，挥发性意味着你必须有一个持续的电源供应，非易失性意味着如果你拔掉电源，再插回去，你的数据还在。
最常见的两个版本，其中之一就是所谓的固态磁盘。
其中之一是所谓的硬盘驱动器，固态硬盘，原谅不是固态不稳定，SSD是什么，它通常是创建你使用一个构建使用所谓的闪存，这是一种略有不同的技术，但这里的想法是，现在我们在40到100微秒，对于那些不太记得。
纳秒和微秒的区别，纳秒是十的负九，微秒是10的负6，好啦，所以这比上一页的DRAM慢了一千倍，但是要便宜得多，DRAM是每千兆字节三美元，现在我们是，我们看到的可能是每千兆字节5美分，你可能见过一些。
呃，之前的一些标识，像西部数据，这些都有点像固态硬盘，但这里的想法是它是一个集成芯片，半导体技术是电子的，但它也是不易挥发的，另一方面，我们有机械硬盘驱动器，他们实际上有这个旋转。
这就是为什么它们被称为硬盘驱动器，然后他们有一个小机械臂，移动比固态硬盘便宜，也更稳定一点，我们将在一两周后进一步讨论这个问题，现在访问是五到十毫秒，毫秒是十的负三，所以这比SSD慢一千倍。
所以这是一种，我们在这里看到的角色。
如果你有兴趣，这里有一段尼克·帕兰特的视频，我在斯坦福大学的一个同事，硬盘，他真的把它拆开了，然后你可以看到它就像机械，我只是做像商店商店反正，这是一个很酷的视频，好像有六分钟长，建议大家看一下。
如果你对SSD感兴趣，事实证明，固态硬盘是因为它们不像在单个芯片上，它们实际上可以像堆叠在一起，一种闪存中的三个D，方式类型，上课，如果您想了解有关SSD的更多信息。
那是固态硬盘，又是这样，这有点像有趣的信息，对你有用，如果你有点像生活在CEF的生活中，但我今天想说的是我们的记忆是有物理限制的，以及存储或辅助内存的物理限制，因此。
我们需要某种方法来管理这些物理上有限的资源，在所有这些不同的过程中分享它们，这就是所谓的虚拟内存，还有虚拟地址，因为有虚拟内存。
我将用来激发虚拟内存的用例，您可能会想到更多的用例，但我觉得这两个人，在思考多编程方面最明显的，当多个程序共享同一内存时，如果主存很小怎么办，与程序地址空间相比，我们稍后将讨论地址空间的定义。
但相对简单，左边，这里我们有风险5 32位地址空间，那是什么意思，这意味着如果我们有字节可寻址内存，风险五架构说嘿，最多可寻址4G，好啦，所以这有点像，这个巨大的阵列就像在看这里，那是2到3 2字节。
那是五分，这就是节目所期待的，对吧，所以堆栈在最上面，就像所有的F，然后代码在最下面，然后堆在中间的某个地方，但就像程序期望的那样，你可以使用所有的空间，但是，如果你的DRAM。
如果你的主存只有1GB呢，就像身体上一样，你只有一首单曲，就像我们在上一页看到的那些小块，那么您将只有2到30字节的可寻址内存，相差四倍，那么你是怎么做的，你想尽力做好什么？
这里是这里是这里是一个解决方案，你说，好啦，我只是要尝试和地图，就像，我不知道，每次256个字节进入这个特定的物理内存空间，好啦，所以这里就像块，拦截器从所有零开始，这是下一个街区，这里是第三个方块。
这里是第四个街区，然后第五个方块，我的天啊，我就像没有空间了，就像没事一样，这可能不是该走的路，好啦，从某种意义上说，好啦，这里的洞察力是什么，洞察很可能，嗯，你们正在运行的程序可能很小。
所以你并不真的需要所有的两到三个两个可寻址的内存位，好啦，那么你如何计算出哪些字节保存在哪些内存中。
留在里面，或者说哪些数据要保留实际内存，问题是，这是第二个动机，即多个程序访问同一个内存地址，让我们考虑以下几点，假设现在我们有更多的公羊，我们决定一场演出是不够的，根据之前的幻灯片，我们就像，好啦。
让我们扩大到四个G的公羊，味道很合理，是啊，是啊，然后你有两个程序，你设法把他们，所以他们是一体的，分别是一个千兆字节和两个千兆字节，但让我们假设他们访问和覆盖相同的内存地址，例如。
也许程序一就是你的银行，你的银行程序，这就像把你的账户余额存储在这个地址一样，文本四百，所以它存储了四十二个很好的，也许你的化合物里有四两美元，那很好，但是你有程序二，上面写着，好啦。
现在我要同时运行一个电子游戏，在同一个操作系统上，就像在同一台电脑上，你会喜欢，我不知道，也许这就是你的生命数量，或者大约一万，然后你再把它储存起来，见鬼，四百块，会发生什么，突然间你变得富有多了。
但也不知何故是的，是呀，但就像是的，好啦，所以，但喜欢反正，程序已经覆盖了另一个程序数据，这很糟糕，这就是我们所说的腐败，好我们可以，你知道的，我们可以在这门课之外讨论腐败的其他定义，但那不是。
这就是这个想法的重点，我们要讨论的是数据损坏，这就是操作系统，虚拟内存类型的东西需要处理什么，保护程序或进程不受其他进程的影响，所以它们有不同的空间，他们甚至不知道彼此的存在。
它们不会干扰彼此如何运行和保存数据，或者访问他们的数据，所以这就是我们现在所处的位置。
我们有，好啦，谈谈定义，你先坐一下，因为时钟就像，好啦，所以如果你们知道，我不知道你们知不知道，但是在后面有一个红色的小钟，十一十四，现在不是时候，十四十，好啦，但这是我通常看的那个，我很害怕。
所以我吓坏了一秒钟，但我们还有20分钟，好啦，所以我们可以谈论虚拟内存，让我们来谈谈虚拟内存，虚拟内存是一个想法，你可以看到时钟，编辑你自己的时钟，有些人不是别人的道路，但让我们在地址的上下文中讨论。
进程拥有完整内存地址的想法或错觉，它可以和，它是孤立的，从某种意义上说，它不知道有另一个进程在运行，它还认为它有足够的内存地址空间，不知何故，这种管理正在发生，它解决了两件事，其中之一就是这种保护理念。
因此，避免从其他进程损坏进程，其中之一就是记忆是固定的，假设我们只有四个gib字节的ram，然后所有其他潜在的误差，比如进程需要访问的地址就在磁盘中的某个地方，好啦，所以这有点像在RAM中工作信息。
然后其他到目前为止还没有使用的东西都在磁盘上，每个程序，这就是虚拟内存所完成的，这里有一些好处，我们会再次报道Lyde，一旦我们确切地看到虚拟内存是什么，但其中一个想法是所谓的需求分页。
这大概就是我所说的，但我要再说一遍，程序将运行，它们会增加它们所拥有的内存足迹，换句话说，也许他们一开始在主存中没有信息，然后当他们跑得更多的时候，它们将更多的信息从磁盘加载到内存中。
然后更多的信息从磁盘到内存，但如果他们暂时不逃跑，这些记忆慢慢地被赋予其他进程，等等，等等，所以这是按需寻呼，稍后我们将讨论什么是分页，第二件事是我们在操作系统中讨论过的保护问题，第三件事是，实际上。
这个虚拟内存的想法实际上隐藏了不同的机器配置，好啦，所以即使一台电脑有4G的内存，另一台电脑有8G的内存，另一台电脑有16G的内存，程序都可以相信他们有2到3 2位或3位，两到三十二个可寻址的咬位。
咬可寻址存储器，至少在节目现场，虚拟内存给你带来了一种抽象。
今天所有这三个差异，或者像这三个好处一样，哪个最有用，事实证明，它实际上是不同过程之间的保护，当我们进入一些应用程序时，我们会更多地讨论这一点，但这里的想法是公羊变得如此之大，就像记忆变得如此之大。
进程共享内存实际上没什么大不了的，但它们绝对不应该互相覆盖，无论发生什么，好啦，除非他们被允许，今天是术语课，不过，别担心，下次我们也会复习很多，我说过地址空间，我只想说现在我们实际上有两个地址空间。
这就是虚拟内存的力量，第一个是所谓的虚拟地址空间，第二个是物理地址空间，我这么说是什么意思，虚拟地址空间是我们之前讨论过的风险五的土地，也就是说，每个程序或用户程序都认为它有从十六进制零。
一直到十六进制，在这个三位两位可调的空间世界里所有的F，物理地址空间是您在以前的幻灯片中看到的那些橙色框，这是可用的实际内存，这里可用的内存的实际字节地址，这对用户应用程序和虚拟内存是隐藏的。
所以这里的想法是程序总是在这个虚拟地址空间中运行，有某种翻译器可以翻译所有这些虚拟地址，所有这些访问和所有进入物理访问的东西，到内存或两个磁盘，你会听到我说这个词记忆管理器，但我会试着用翻译这个词。
因为我真的认为这就是这里发生的事情，将一个虚拟地址转换为物理地址。
让我告诉你一个有点像，让我给你看一个图表，可能会对这个想法有所帮助，假设在左边我们有多个过程，都同时运行，并将它们表示为不同的核心，或者你知道，就像一个不同的CPU，你可以想象所有喜欢不同的CPU。
也总是访问相同的内存，这是一个有用的，这是一种有用的思考方式，但这些也可能不同，就像CPU的咒语一样，它运行得非常快，同时非常接近，所以这些都是不同的进程，都在运行，他们都认为他们有自己的虚拟地址空间。
这包括工作人员，堆，他们自己的程序代码，就像在文本部分，他们自己的程序数据，所有这些类型的事情，好像有三份不同的副本，或者更确切地说，他们甚至不知道有三个独立的副本，他们只知道他们有自己的副本。
这就是虚拟地址，但是，引擎盖下发生的事情是那三份副本。
他们只是回到上一张幻灯片，那三个虚拟地址副本。
它们都映射到相同的物理记忆中，可能要小得多，所以这个翻译器所做的，或者内存管理器每次，任何进程都想访问内存中的某些内容，它总是通过这个记忆转换器。
你知道它总是通过记忆转换器，然后可能程序一就会像上面这个区域，可能程序二得到了第二个区域，可能三号程序会进入第三个区域。
但它不知道程序，不知道这个，操作系统做什么，就像操作系统的翻译器，就是，它只是将这些虚拟地址映射到物理地址，现在呢，有点复杂，如图所示，这些区域是毗连区块，原来它不是连续的块。
但这正是我们接下来要讨论的。
但在那之前，我只是想给你看看蜂巢机是怎么说的，关于这些地址空间，所以如果你呃中央处理器的信息，所以如果你只显示蜂巢机器的CPU信息，你会看到所有不同的处理器，你得到的所有不同的信息。
你可能已经在之前的课程中看到过了，我想用这个给你看看，呃，这个特殊的CPU信息，在最下面有一条小线，地址大小，上面写着39位可见和4位8位虚拟，我的天啊，所以这里好像发生了什么事，你就像，你知道的。
就像，如果你是个网络侦探，东西，你不知道虚拟内存，你就会看到这个，你就像，嗯哼，这是人们没有告诉我的事情，但我们现在告诉你。
我现在告诉你，所以我要以什么结束，他们很像吗？你知道的，这节课还有两个部分，但我要从，虚拟内存的概念真的很详细吗，好啦，但是为了理解虚拟内存，我想让你就像，你知道的，回到两周前。
忘掉你所学到的关于缓存的一切，我知道你喜欢，你为什么要这么做，是啊，是啊，我知道，不过没关系，所以事实证明缓存会很有用，因为他们就像真的一样，我们要看看它们是如何相互作用的，但这将是非常混乱的。
如果你现在考虑缓存，所以我们现在的抽象是，如果CPU想要访问内存，它必须一直到萨克拉门托，这里没有中间，这只会让下一节课更容易，然后我们将带回缓存并展示它是如何工作的，但现在假设每次内存访问都很慢。
好啦，有没有有没有，这里没有加速，我看到每次内存访问都很慢或更慢，好啦，所以你要么进入主存，或者你一直到磁盘，好啦，有没有有没有，这里没有捷径。
好啦，这就是我们正在使用的版本，这对我们有什么帮助，让我们考虑一下在这个领域中什么是有用的应用程序。
在那里我们没有任何缓存，嗯其实，也许这是一张很好的总结幻灯片，我要再重复一遍这张幻灯片，可能下次也是，但是这个虚拟翻译有三个责任，或者虚拟内存管理器必须做其中一个。
其中一项职责是为每个进程将虚拟地址转换为物理边缘，第二个是它必须有效地利用资源，所以如果我们只有缓慢和缓慢，AC将尝试管理内存之间的权衡，类似于内存的东西以及存储在磁盘中用于每个进程的东西。
它要做的第三件事是保护的想法，启用内存访问的排序，所以每一个过程都是孤立的，除非他们应该写在相同的位置，让我们详细地讨论其中的每一个。
但是让我们来谈谈页面内存，所以我要，好啦，所以我告诉过你要把一切都想清楚，让我让我像闪现一点缓存，记住缓存是如何像块一样的，你一次加载块和单词，现在我们要一次加载页面，页面要大得多，这里会有一点背景。
虚拟内存实际上是在缓存出现之前发明的，所以它使用了一个稍微不同的术语，我知道这很让人困惑，但这实际上会帮助你思考维度，在记忆的数量级上，所以页面内存，我这么说是什么意思，我的意思是，记住。
内存中的所有东西实际上都是从磁盘中的某个东西复制和加载的，所以这里发生的事情是，当任何东西从磁盘加载时，它实际上是以页面为单位加载的，挺大的，所以现在在现代操作系统上大约是四个KB字节，因此。
如果您有四个QB字节的数据，然后你把这个加载到你的记忆中，那么如何访问每个字节的数据，你在那里需要什么，比如你需要什么样的地址，你需要十二个比特，也许是因为如果你有四个QB字节，那是十二字节的二。
如果你想索引每一个字节，你需要12位我们称之为页偏移量。
为什么这有用，记住第一步，第一步，我们希望内存管理器将虚拟地址转换为物理地址，但这里有一个诀窍，许多内存管理器，事实上，所有内存管理器使用，也就是说，让我们保持物理页面和虚拟页面的确切大小相同。
翻译只是变成哪个虚拟页码，映射到哪个物理页码，然后这些地址的低位都是一样的，因为那是页偏移量，它有点提醒你自己那个缓存是什么，就像标记索引偏移的东西在这里，我们是说补偿都是一样的。
这使得我们可以非常有效地进行翻译，我们只需要查找哪个物理页码，ppm映射到哪个虚拟页码，反之亦然，所以让我们来看看这个，那是很多信息，所以让我们来追溯一下这个的两个版本，你看这里我有一张页表。
哪个是我们的查找表，在这里我把它放进云里，因为页表的写法和这个略有不同，但我的想法是，让我们假设我们要将一个字节加载到寄存器中，我们想通过文本加载，f，f，f，zero，one，to，t，zero。
in，x，zero，只允许我加零，这就是我们正在调查的地址，为了让这一切再次发生，程序只是在虚拟地址空间中工作，所以程序认为这确实是字节的地址，它想装进去，现在它尝试访问内存。
然后操作系统就像没有坚持住，我帮你翻译一下，其实呢，它甚至没有说不，就像是，哦耶，是呀，是呀，是呀，然后它就像偷偷翻译一样，然后得到信息，但是你知道，想象一下，所以页表，页表在这里做什么。
计算机实际上是操作系统，我们会更多地讨论这个问题，下次我们将分几个步骤将这个虚拟地址转换为物理地址，第一个是，它将尝试提取页码，虚拟页码，如果我们在处理一个3位2位可寻址的虚拟空间，每页都是二到十二位。
我们的页码将是前20位，这有点像想在这里快速地把它们脱掉，然后页表有一个巨大的，它只是一个巨大的查找表，页表上说可以，哪个虚拟页码，或者如果我在这里找到虚拟页码，是哪个物理页码，所以在这种情况下。
我们查一下，好啦，我们说好，这里最有趣的部分都是FS，我们在页表上查一下，哎呦，那是最后一排，最后一排，我不知道，我指的是，我有最后一排的一点，这里实际上是物理页面的第一页。
所以它进入了物理页面的第一页，但现在哪个字节加载得很好，它只是物理页码的串联，和原始页偏移量，那么这里的页偏移量是多少，页偏移量是虚拟地址的较低的12位，连接到物理页码的上二十位，在这种情况下都是零。
最底层的人，所以发生的好事，也许在我们这里的DRAM里，假设这是我们的尺寸，第0页是第一行，第一页是第二行，我们只是一直到最低的字节，我们加载那个字节，好啦，事情就是这样，所以让我们完成第三步和第四步。
第三步是它现在确实位于内存中，所以我们只是去访问物理内存，然后第四步是我们把咬到的东西，我们把那个字节返回给程序，好啦，不是那样的，让我们在这里再举一个例子，让我们假设我们处理的是。
让我们假设程序现在要加载，呃一千三十，好啦，它怎么会做同样的事情，页表会说，是呀，是呀，是呀，是呀，那个地址肯定存在，嗯哼，嗯哼，然后就像第一个，前二十位，六万查一下，这就是虚拟页码，查一下，就像。
我的天啊，它不在这里，它不在物理页面上，那么它是做什么的呢，它访问磁盘，它访问这个，在页面中加载对应于特定数据块的，在这一点上，现在它已经加载到那个页面到内存中，离开磁盘或离开磁盘，更新页表说，好啦。
也许这个页面现在在物理页面的第二行，最后它从内存中读入数据，好啦，注意这里有两个入口，在薄雾中，好吧，秋天在这一页上，我们下次再谈这个，但页表上写着，好啦，我们得一路走到磁盘上，所以OS做的是说，好啦。
我要一路走到磁盘上，将该页加载到内存中，然后我要把那辆自行车从记忆中加载回过程中，这里有两个入口，就这样了，这就是虚拟内存在一个非常非常高的水平上，好啦，那么页表是什么样子的呢，你知道我之前在云端。
所以让我们看看它是什么样子的，假设以下情况，所以我们仍然在处理同样的想法，这里我们有三个二位的虚拟地址空间，那应该是小写的，B我会解决的，小写b，我们做到了，这里的小写b位。
然后我们这里有2到12位的页面，如果是这样的话，我们有多少虚拟页码，如果我们寻址到每页12个字节，然后我们有两个到二十个虚拟页码，页表是什么样子的每个进程只有一个页表，因为这就是这个特定程序的所有查找。
它要做的是，顶部的页表实际上是实现的，每个虚拟页码都有一个条目，那个虚拟的入口会有一些东西，物理页码或磁盘（如果不可用），磁盘地址（如果不可用），也可能是一些状态位，我们下次会更多地讨论。
这个是如何地址的，或者这个是如何索引的，那么好吧，每个条目，有入口的零，这里是带页码的零，然后这里的最后一个条目，所有f的十六进制，那是最后一页的号码，所以用缓存术语来说，它有点像虚拟页码。
下面是页表项的索引。
尽管我说过这是最重要的一点，这就是为什么我喜欢把它栓起来，如果你有讲义，你真的应该试着把它圈在这里，页表不是缓存，这就是为什么我们很方便地忘记了缓存，除了当我方便地把它带回来的术语，好啦。
所以页表不是缓存，为什么这里没有空间局部性的东西，有了这个查找表，每个虚拟页码都有一个条目，好啦，虚拟页码没有覆盖，内存中发生的页表中的其他虚拟页码，但不是在页表本身。
所有虚拟页面页表都有一个有效的条目，但如果这对你有帮助，也许又是一些术语，暗想缓存，就是，这里没有标签，索引是虚拟页码，就是这个想法，页表只是一个查找，现在呢，这有什么帮助。
这里有一点我只想用我们所拥有的来结束，现在，我们有一种方法可以通过这个页表进行翻译，虚拟到物理地址，我们有一种既使用内存又使用磁盘的方法，通过这个想法，如果它不在记忆中，然后操作系统将进入磁盘，上膛。
然后用正确的信息更新页表，但是这种保护思想呢，如果两个进程访问相同的内存，会发生什么，下面是视图的样子--每个进程都有自己的页表，假设我们这里有三个过程，我们有橙色的。
绿色的和蓝色的，他们都有页表，然后这些突出显示的是，呃，我们走吧，是啊，是啊，页表中这些突出显示的条目是那些在内存中有位置的条目。
幻灯片底部的最后一个要点，您可以拥有跨不同进程映射到相同页码的虚拟页面，例如，也许您需要查找当前运行系统的用户，应该只对两个用户进程都读取的某种系统数据。
在看这些数据，那么，这是如何通过状态位权保护来实现的呢。
所以在这个特殊的情况下，我是说再来一次，我们没有特别的数学，也许我会稍微更新一下图表，但如果状态正确，然后页面受到保护，这意味着这两个程序，如果他们看到这个虚拟页面，他们只能从那一页上阅读。
如果他们试图存储到那个页面，然后操作系统就会触发，所谓的例外，然后不允许事情发生，也许中止这个过程，那么这是如何工作的呢，啊，有点诡异，下次再说吧，所以我们星期三再来，我们将更多地讨论虚拟内存。
这将是一个好时机，你们星期一过得愉快吗？记得投票，谢谢哇。
P43：Discussion 11： Parallelism, Coherency, and Atomic - 这样好__ - BV1s7421T7XR
最近怎么样？每个人，到目前为止，每个人对平行度的感觉如何，像上周一样报道了这件事，但我们面前有很多相似之处，所以说，是啊，是啊，嗯，呃，我们有第三个项目，这星期三到期，明天我们还有另一份作业要做。
嗯无与伦比，家庭作业八，是啊，是啊，呃，我觉得应该是无与伦比的，是呀，是明天的家庭作业，我出来了出来了，是呀，是呀，是呀，是呀，我知道第七份作业已经到期了，是呀，让我们做最后一个，所以是的，所以我们要。
有点故障，不是吗？好了嗯，我们要覆盖线程级别，数据级，平行性和现金一致性，还有一点关于原子的，只是为了感受一下这个房间，让我们直接进入预检查，尽我们最大的努力，然后我会在一瞬间走过一分钟，给你几分钟。
每个人都在一个很好的位置，一个一个，每个人怎么会觉得是真的还是假的，假的也假的，呃，是呀，是呀，完全是假的，所以辛迪能告诉我辛迪代表什么吗，真正快速的单指令多数据，是啊，是啊，就是这样嗯是的。
我想指令级并行性是一个过载的术语，我想在演讲幻灯片里有一个音符，就像辛迪，是指令级并行，但他们使用了不同的指令级并行定义，但基本上这里的主要收获是，我们有一个操作同时发生在多个数据上。
不是两个不同的指令，我不认为，好啦，呃，一点二真假，辛迪真的只是一种理想的重复操作，所以如果我们有一个长数组，我们需要在整个数组上计算一个操作，那正是辛迪发挥作用的地方，一点三，让我想想，像下划线，嗯。
一个，两个，八，所有的资产实际上都对应于你芯片上的特定寄存器，比你的三个大，两位寄存器专门用来保存，假设四个整数值或四个浮点值，嗯，所以这些SIMD说明只允许我们专门使用那些，是啊，是啊，这就回答了。
呃，一分，五个，等一下，否，对不起，一分，四，呃，是啊，是啊，是假的，是啊，是啊，共享缓存会很乱，如果我们有多个线程做不同的事情，嗯是的，对每个硬件威胁都有隔离的缓存符合我们的最佳利益。
这实际上把我们带到了缓存中，凑在一起，看看我们一会儿再谈哪一个，是啊，是啊，所以当他们说每个硬件，意思是像这样，就像三十一，喜欢一台电脑和一组寄存器，所以硬件线程，你几乎可以认为是通过CPU核心的路径。
好啦，假设你有一个四核CPU，这将带我们进入下一个问题，有点嗯，但它们基本上就像硬件组件，使我们能够通过我们的核心发送指令，这回答了你的问题吗，就像核心通信，右右，一个核心对应于你做的。
或者你在第三项目中，几乎是一个数据路径，是啊，这就像艰苦的工作，对吧，那是一件事，是啊，是啊，但是呃，我们能不能，我们可以有两个，有一种东西叫做超线程，所以有一个想法是，你的数据路径，假设你有四个核心。
你的第一个核心正在等待一个过程，这个过程必须在第二个核心完成，所以这就像无所事事地坐一会儿，因此，拥有多个硬件线程符合我们的最佳利益，我们现在可以发送另一个过程，当一个硬件线程在等待时，是啊，是啊。
这些，我们这里有很多条款，所以我们有硬件线程，我们也有软件线程，对呀，线程级并行性，我们也有核心，但也，课程本身，他们分享，你有一个，我们有一个像L 3这样的节目，对吧，通常，是啊，是啊，是啊，是啊。
但是呃，如果我们有多个硬件线程穿过那个核心，我们可能有两个单独的缓存，一级缓存相当便宜，它们很小，它们在处理器上，现在，如果我们开始下降2 l 3，我们开始考虑更大的缓存，这种缓存关闭或关闭处理器，嗯。
那些通常是共享的，是啊，是啊，但如果你有道理，你对此有何感想？那里有很多细节，很多都超出了这门课的范围，但如果你好奇的话，有好的事情可以思考或调查，你想知道一个问题的答案，六个。
速度与硬件线程的增加成正比，这是个复杂的问题，呃，有个话题，你们把它盖上了吗，比尔定律讲座，他们一直在乱提，好啦，但你没有，我这里有一个等式，你看过这个吗，你没有，哎呦，两个月前的话，是呀，他们只是说。
哦不，好啦，嗯，我们都会学到，今天的阿马拉地段，这在范围内吗，因为他们从来不喜欢，我不知道为什么，我写了两遍，但这只是一个等式，是啊，是啊，它是，它是，呃，所以在平行度的范围内。
我们可以开始衡量我们实际上在多大程度上加快了我们的计划，我们代码的哪一部分可以并行化，以及它能以多快的速度上升，所以我们有两个参数，在这个方程中，P只对应于，比如我们整个代码的总执行时间的百分比。
我们的整个计划，是呀，它是速度增加的百分比，由于代码中的一个小优化，假设我们有一个C文件，里面有十个函数，但是其中一个函数，我们可以做一个，比如杂注，P平行四，它使它的速度提高了四倍，对呀。
这只是这个文件中十个函数中的一个，但我们可以运行它，呃说，4倍的速度，在这种情况下，我们的s将是，与提速相对应，然后p将对应于我们的程序现在运行的速度，在我们把之前的数据和之前的数据进行对比之后。
所以我在这里写了一个快速的例子，嗯就像说，在并行化我们代码的某些部分之后，那个功能是两倍的快，呃，这有点放大了，所以我们的s是2，嗯，现在让我们假设我们的程序运行速度比过去快30%，因为那个速度。
所以我们的p是零点三，所以这就把它们扔进了等式中，它会告诉我们程序的整体速度，因为有些部分是无法优化的，我们的代码会有一个基线成本，所以我们真的不能，呃，通常呃，获得百分之百的效率，但是，嗯是的。
这只是一个很好的等式，在一张纸上参考它，下次做作业的时候用吧，但是，It’那是什么样的，所以我们正在解决你代码的测试版，比如你在解什么，或者这是什么，嗯，所以这就像我们节目的速度。
与我们在程序中实现的这个小优化相对应，作为线程级优化，是的是的，只是一些线，呃，这个哦，这只是说，所以说，我们的程序中有一个函数，我们已经并行化了，它现在的运行速度是以前那个函数的两倍，嗯，所以这就像。
这是两个，所以这个函数现在加快了两倍，因为你必须，啊，因为你是最佳人选，我们在考虑总的执行时间，不一定像特定的线程，嗯，我是说，就像说我们在做，我们甚至不要去想线程。
让我们假设我们只是做一些D什么样的速度，你能想象我们能和辛迪，通常，我们通常有4倍的速度，因为在大多数情况下，我们可以在寄存器中放入四个整数，把它们同时相乘，所以这就给了我们四个s，是啊，是啊。
P和S的确切区别是什么，因为读了描述，我觉得他们有点多余，就像p就像执行时间，的速度，S也有点像优化代码的加速，因为我觉得我觉得这些都是多余的，但我不确定到底有什么区别，就整个程序而言。
S是我们优化的部分，好啦，是啊，是啊，是啊，是啊，会继续向DLP前进，已经说了很多了，嗯，但是我们之前说过的想法，我们只有一条指令，我们希望同时对多个数据进行操作，嗯所以是的，它们不是数据类型。
它们实际上是寄存器，你会看到一些看起来像铸造的符号，这只是向编译器指定，你要用某个寄存器，不是真正的演员，因为这些不是数据类型，嗯，但是是的，你经常会看到你是否想理解这些，这是256位的寄存器。
然后我们做加法运算的指令，然后像组件类型，你想读一读EPI代表什么，我想曾经知道它代表什么，但是是的，或者经常会在使用说明列表中给你一个问题，会有一个描述告诉你具体的指令是什么。
你不必用任何方法记住这些，好像有几千个，那么让我们来看看第二个，我们得到了这些指示，我们在这里有这个函数，我们想用SIMD来优化这个功能，花点时间，我们一会儿再来讨论这个问题，有人想跟我说说吗。
或者你可以谈谈，啊，我们去讨论第一行，我们需要初始化这个prod v准备好，是啊，是啊，是啊，是啊，完全正确是的，所以我们有，嗯这个说明书，好吧那我们就这么做，你知道吗，我不会把这些都写出来。
我就写第一套第一套是所有人，好吧，这一点，好啦，嗯好吧，呃，所以我们有两个循环，让我们，让我们讨论第一个for循环中的参数，谁有什么想法，除以四，除以四乘以四，是啊，是啊。
每个人都明白为什么我们除以四乘以四，所以他是说，我们除以4再乘以4，您希望第一个结果给您一个整数，楼层，整数的底数，然后把地板相乘得到，它是一个，而且是的，所以我们要乘，对不起，n除以四，对呀。
但是我们还需要乘以4，呃，那是什么，这对我们有什么好处，我们为什么要这么做，好像没什么意义，你得到了最高的水平，四，不到十分钟，是呀，是呀，完全正确，这么说，我们有18号，说n是十八岁，我们除以四。
这样我们就有四个人了，四乘以四十六，这是四次迭代中最小的一次，我们可以进入每一个，这样我们就可以一次分离出四种元素，从这个意义上说，保持不变，呃，同样的想法，下一个for循环呢，呃。
我们在下一个for循环中初始化什么，这个就在这里，因为这就是我们在第一个循环中停止的地方，这就是我们想在下一个循环中继续的地方，这叫我们的尾箱，每个SIMD循环都会有一个尾箱，我们总是有最后一个小循环。
我来处理，最后几个我们不能在倍数四中处理的元素，是啊，是啊，好啦，所以呢，这个呢，就在这里，我们增加了多少，我买，然后我们也要完成这一秒钟的循环，当我小于，而且是的，好啦，所以有两个循环，嗯。
现在第一个循环，在这个循环中我们需要做什么，该功能的总体目标是什么，是呀，我们要去，我们要把数组中的所有元素相乘，我们要找到整个产品，所以这条内线，这个产品，的，所以在SIMD中。
我们有一些指示可以使用，我们对哪些感兴趣，这里的这个是我们在这个案子中所需要的，嗯，我们可以开始写这个，所以我们又有了莫罗，我是，我是个小速记，但是，所以第一个寄存器输入可以是。
我不确定我们是不是该打电话，加载你，或者我们应该拥有并保持，是啊，是啊，这是因为我们有一个整数数组，对呀，呃，我们需要通过一个像SID寄存器这样的寄存器，可以利用这个加载指令，现在看参数和加载指令。
我们在这里做什么，关闭，嗯，你知道，你起来了，是呀，是呀，是呀，你们在正确的轨道上，所以让我们，我们就写吧，负载，你，但在我提到我们之前，我们有一个奇怪的铸造符号，这基本上是要告诉计算机，是不是毫米。
是啊，是啊，在两个下划线下，一二八一，然后这将是我们的一个加分，这对每个人来说都有意义吗，我们基本上是在指定，这将是一个寄存器指针，指向四个整数元素，所以你能涵盖你真正要求的部分吗，四要素。
每次都是负载，启动器会给你一个指针，一百二十八颗星，就在这里，是啊，是啊，是啊，是啊，是啊，是啊，所以它是，呃，有点像石膏，是的，嗯，所以我们指定，因为在这个加载指令中。
它采用了m-1-2-8-i指针类型，意思是它需要取四个整数，嗯，所以我们要给它一个指针，在该指针处携带整数，但如果我们给它一个指针，它是，它将指向一个整数，所以这是在做什么，它是，它说它在期待。
这是由4个整数组成的级数，我们将用这个指令把它加载到寄存器中，所以现在我们有一个寄存器，包含这个指针的四个整数，这里的a代表什么，A只是传递给函数的参数，所以A是我们需要相乘的整数数组，是啊，是啊。
是啊，是啊，所以基本上问的是负载函数，它会看到策划者A加I，然后把第一个精确地，是啊，是啊，是啊，是啊，大家都清楚了吗，加上我因为，哦尺寸，我就像在照顾指针，是呀，是呀，观察力好，是呀，好啦，是啊。
是啊，就像加载内存的实际地址一样，它怎么能加载，哎呦，等待它从每一个加载，然后呢，所以它允许从地址a开始的四个整数，加上我正好，是呀，是呀，好啦，好啦，所以不要这样做，施法不管用，呃，我不这么认为。
我没试过，呃，也许在你的下一个项目中尝试一下是件好事，但你是说这不是真正的课程，因为我们不一样，不像真正的类型，是啊，是啊，这不是真正的类型，就像一个，它是，它与CPU中的寄存器相对应，哎呦，是啊。
是啊，控制哪个寄存器和什么寄存器，或者只是在这里做，就像，我真的不能告诉你发生了什么，如果将浮点数传递到整数寄存器中，嗯，我不知道该怎么跟你说，呃，但我肯定会试着坚持整数寄存器，浮点寄存器，你知道的。
保持它们的一致性，是啊，是啊，但是是的，你只是，您只是指定要使用哪个寄存器，好吧那我们就开这家店，你在这个循环下的指令，所以我们完成了我们的循环，我们创建了四个产品的向量，一直到四的最大倍数。
所以现在我们有一个电话要储存你，我们在这里做什么，添加，呃，什么你，呃，所以我们需要找到所有值的乘积，所以我们不想求和，嗯，你为我们做了什么，呃说，存储128位矢量，at指针，P。
所以我们要从向量SID寄存器到内存中的指针，你想把它移回一个指针，回到数组，所以你以后可以把它们相乘，我喜欢，所以关于我们传递到这个函数中的内容，第二个会在那里为这个这个东西，所以第一个，你的意思是。
呃，你我们要储存勇武的成果，对呀，是啊，是啊，是啊，是啊，是啊，是啊，所以我们要通过结果，我们能不能把结果，所以您还必须将它强制转换为类似于寄存器类型，我有什么必要把它弄进去，你就是这样，如果我们回到。
在这里说明那个指令，我们注意到这是m 1 2 8 i指针，所以我们要把结果，我们将把它铸造成这个寄存器，我们要传递什么，我失去过任何人吗，我可以我可以回溯如果你想的话，这是我们存储我们的指针。
这里是Prod v，到目前为止，这就是我们的产品在这个Prod V寄存器中的内容，我们要把它扔进结果里，你指导的这家商店要做什么，就是，它要把这个，一二八寄存器，将这四个值扔到内存中的这个指针上。
记住我们不会有结果的，寄存器，我们不像将结果加载到寄存器中，嗯，这只是为了一致性，就在这里，它现在储存了我们的产品，到目前为止我们有四个元素，它们都是一些数字的乘积，所以现在我们要进入我们的尾箱。
零次的结果等于什么，是啊，是啊，我不认为那的利益应该是一个，是啊，是啊，所以我们将把数组中的最后几个元素，我们要把它们成倍增加，我们可以把它们相乘成，我们可以把它们乘成两个的结果，没关系。
因为最后我们要，我想我有点破坏了它，但最后我们要取四个元素的乘积，结果和回报，所以我只是告诉你，但是是的，我们只做零次，相当深入的问题，所以如果我们需要回顾一下，求求你了，是啊，是啊，回到标题问题。
它是数据级并行的，这是，之所以这么叫是因为我们会说出更多的数据，就像，对了20个整数，说最简单的方法是，我们只要做一个for循环，0乘以a等于i的a，然后遍历每个元素，这将需要20次for循环迭代。
这种情况下的二十次乘法，其实我们不会有尾箱，对呀，因为二十可以被四整除，呃，我们将对第一个for循环进行五次迭代，我们会有五个乘法，但是我们仍然有这四个乘法，但大量的人说阵列大约有5000个，我是说。
你是，你现在得加快速度，这是一个不断的现实，以产生最后的回报，总是四行，不管右边的大小，最后一次返回，是啊，是啊，所以我们不在乎，呃，我们正在做的事实，呃，零的结果，是啊，是啊。
但就像我们有一个由20个元素和500个元素组成的数组，像四个乘法是一个很大的，总乘法的较大部分，我想没有，我的意思是总的乘法，但这是，是啊，是啊，有一个小问题，那是DLP，呃。
我们有一点时间来进行TLP，嗯，每个人都对TLP没意见，到目前为止，我们有杂注p平行，平行于，基本上，这些是我们可以抛出的快速命令，就在代码块的顶部，所以并行的pragma将占用一段代码。
并在多个线程上运行该代码，软件线程，不是硬件线程，语用不会平行，因为如果你把它放在for循环之前，它将中断for循环的迭代，并将它们发送到不同的线程，因此，我们需要非常小心代码中的内容，因为它。
代码块本身取决于在其他线程中设置的值，我们有很多问题，让我们来看看我们有的几个，A部分，我们有实用主义，平行，然后盖住这个循环，所以它在问，有时是不正确的吗，总是不正确，如果是正确的，比连续剧慢吗。
或比连续麦片快，就像一个面包，我们怎么想，有人知道这里会发生什么吗，是啊，是啊，或者任何你应该储存在材料中的东西，因为这就像你基本上在做每一个产品的整个循环，你喜欢，是啊，是啊，就像，就像非常棒的一点。
是啊，是啊，所以我们要把整个for循环，然后运行它，但是，我们得到的许多线程真的很低效，它比只在一个线程上正常做要慢，是啊，是啊，接得好，那是给一个，是啊，是啊，是啊，是啊，比连环杀手还慢，所以真的。
我们没有优化任何东西，我们实际上在损害我们的表现，但为什么它不像通过第一个入口，所以语用学不会是平行的，就像没有四个指令，所以说，它没有拖尾，就像这个做的，那个做的是，上面写着这里的一切。
让我们给你发一个不同的线程，假设我们有四个线程，我们将在四个线程中的每一个线程上这样做，是啊，是啊，它只是把它，我们不知道，所以我们无缘无故地做了四次，基本上，但你永远不知道有多少线程正确。
只是它说它只是，嗯是的，其中一些我们不一定知道有多少线程，我想嗯，但是有什么方法可以指定线程，它会永远瘫痪吗，如果按顺序做更有效率，我猜这就像整个，就像，就像所有的，优化代码。
所以如果在一个线程中完成更有效，从此，只有一口井，否，因为你在指定你的电脑，在多个线程上运行此操作，所以不会像不一样，你错了，它只是会像，好啦，你得到了它像这样运行四次，是啊，是啊，你是。
我想你有办法让我们，或者解决这个问题，优化这个，是啊，是啊，是啊，是啊，没错，我把四个放在那里，因为它会说，好啦，线程，第一，你要做迭代，我等于零，第二，你要做迭代，我等于1以此类推，它会打破这个词。
好啦，所以B部分，这是有效的还是无效的，这似乎有些不正确，好吧好吧，我几乎总是不正确的，因为那里，因为像这样的，这将是辅助数字，就像他们，是呀，我解释，你知道的，很难让人喜欢，做点什么。
我们可能会按错误的顺序做某事，你弄错了，总是不正确的，完全正确，是呀，过境，刚好顺序对了，我的意思是，如果是这样的话，如果n小于或抱歉，如果n是是，少于四个，例如，那么我们有可能只在一个线程上运行这个。
做正确的事，但如果n大于4对，然后呢，五个，我知道，但就像这样感觉就像当你有一个人，就像顺序基本上就像不确定的，但经常喜欢线程，就像在迭代费雷尔，它们实际上是一个接一个地发生的，以正确的方式。
就像也许就像有效地，在那里，艺术品竖起了问题的屏幕，但它仍然通过纯块有效地串行运行，基本上有可能，但这可能不会发生，但这就像一个理论，呃，这个，我我是说，我是说它真的发生的可能性非常小，但是呃。
我得考虑一下，我不知道，啊，你介意吗，如果我加上这个，是呀，所以嗯，你以后会学到的，在cs类中看到了一种叫做调度器的东西，不幸的是，当你和计划者一起工作时，有时会发生什么。
它们有时可以优先处理不同的线程，如果你像某些线程一样优先于其他线程，最后会发生什么，如果你还没有更新正确的值，它将依赖于不正确的值，因为有这么多的数据依赖，你做，关于不正确的值，你不想要的。
所以理论上它可能是红色的，有时可能是正确的，我是这么想的，但是嗯，我认为数组被声明为全局的事实，每个线程将从较低的迭代开始，并增加，I，但我们正在访问较小的索引或索引，正因为如此。
你在假设你知道你不能从，我等于n向下，如果有道理的话，对呀，因为斐波那契就像一个递归函数，所以说，嗯，事实上，我们把它分成多个线程，此循环在不同线程中的多次迭代，那就是一个，它将依赖于其他线程。
不管怎么样，如果我让我们说，我们运行这个上，比如什么硬件线程，就像碰巧的那样，就像反应以正确的顺序进行一样，我可以看着，我想你这样说是对的，如果您在多个线程上执行，但每一根线都做了完整的事情。
以某种正确的顺序，就像在某些情况下，这是完美的秩序，他们做得一模一样是不是假设，就像没有一次投掷会在另一次开始前完成，哦好吧，哦很好，好啦，那样的话，然后是的，是呀，有一种假设，是啊，是啊。
好的一六二覆盖这个，这个内容更详细，所以如果你对穿线感兴趣，请收回，我们能对C做出任何结论吗？就像两个一样，最终答案是不可能的，不正确正确，是啊，是啊，是啊，是啊，看看我们怎么想，完全正确。
它不依赖于任何其他指数，对呀，我们要打破这个循环在不同的线程上，这不取决于其他任何事情，是啊，是啊，确切地说，那，D，问题是平行四，我们在增加指针，有什么可能出错的想法吗，数组不会得到更新的近似。
基本上我认为同一个地方，是啊，是啊，嗯，我的意思是，如果一个线程将数组指针递增，说五次，然后一个线程期望它是一个内存地址，而且是的，指针跳得满地都是，是啊，是啊，现在是两点钟，嗯，我是说，是啊，是啊。
我们没有去现金一致性什么的，但是嗯，你会掩护我吗，如果有人想留下来，我们可以谈谈，真的不对，他们今天应该被覆盖的，嗯不一定，我想它应该被正确地分配，否，就在外面，穿过去，就在后面，就在周围，就在外面。
好啦，没有权利，分配，我确实碰过，有一点上周有一点，所以你可以看看录音，如果你想了解更多，哦，我的天哪在互相交谈，是的，是的，哦，就像如果有人想谈论现金，然后说，我很乐意通过它来讨论，如果有人要离开。
我是说你可以走了，嗯，在那里所有的顺便说一句，在网站上，我们的记录和或在课程网站上，是啊，是啊，他们会像15个一样上传到网站上，节后二十分钟，是啊，是啊，嗯反正，呃，对于那些想留下来的人。
我们在每个状态下都有五种可能的缓存行状态，这张桌子看起来真的很方便，我们在共享位中有我们的有效位或肮脏位，这些位的任何组合都将对应于五种不同的缓存状态，所以我们有多个缓存的想法。
我们可以在不同的缓存中有相同的缓存块，我们希望通过这种方式保持数据的最新性，我们不会把过时的信息写回主存，所以这里的整个想法是，我们有一个修改的状态，表示此缓存块中的数据已在缓存中更改。
它在主内存中已经过时了，如果那个街区因为任何原因需要被驱逐，我们需要将这些数据写入主存并更新主存，但目前我们将把修改后的内容保存在缓存中，所以这意味着这是这个缓存块的唯一版本，在所有缓存之间，好啦。
我们有自己的国家，是啊，是啊，是与特定现金捕获块的状态相对应的状态，特定缓存块，是呀，每个现金块都有特定的状态，所以是的，三位，如果你想想每一个现金块，当我们经历了TIO崩溃，这是地址，现在呢。
每个缓存块将有三位元数据，它会告诉我们，我们能不能，我们指望这个缓存块具有有效数据或有效位，此现金块是否与主存一起被修改和过时，或者更与时俱进，我想这是最肮脏的部分，所以我们对它进行了修改。
然后是共享的，其他缓存中是否有此缓存块的其他版本，是啊，是啊，所以我们有了自己的状态，它基本上是一种经过修改的状态，但也与其他缓存共享，所以如果你看这里一个一个，但现在它被分享了，这里的意义在于。
如果你修改自己的状态，它将把更改传播到其他共享缓存，您正在更新多个缓存，而无需进入主存，我们有一个小组等着我们出去，但是独家的，这是所有共享缓存中唯一的现金块，我想我们刚刚谈过了，但是是的。
这些是关键思想，对不起，你不能通过它，是啊，是啊，他们会在中央指数上上升，论艾德，是啊，是啊，谢谢你。
P44：Lecture 33： VM II： Page Faults,Multileve,Interrupts／Exceptions - 这样好__ - BV1s7421T7XR
是啊，是啊，我们做到了，好啦，所以呃好吧，当班尼说话的时候，我想让你们知道，校园确实发送了关于正在发生的罢工学术工作的信息，这至少目前定于周一发生，从早上八点开始。
丹和我目前正在讨论这对61 C意味着什么，但我们不想抢先说事情会改变，做这些疯狂的事，不过，我们将在周末的某个时候发出一份声明，就像现在的情况一样，对于那些不知道，这次罢工是，呃那个，有，有，有，有。
gsis，有研究生研究员，整个加州大学，实际上是在为更公平的权利讨价还价，所以如果你有兴趣，请务必上网查看，但请注意，这可能，这可能会改变我们的一些员工，但我们在工作还是不工作，我们。
但是加州大学的管理部门正在与这个庞大的工会谈判小组合作，给你，希望星期一能得出结论，这就是为什么我们不想先发制人地发布信息，但就我个人而言，我想这其实是一种令人兴奋的，在那种潜在的打击世界里。
因为我觉得作为伯克利的学生，只是在工作中看到集体行动，但我们可以在今天的另一堂课上讨论。
让我先简单回顾一下我们上次讲的内容，虚拟内存往往是CS六十一C中更难的概念之一，因为它把你目前看到的很多东西，所以这就是我们现在的处境，我们有一个CPU，即使我们有多个处理器，无论在特定的计算机中。
我们可能正在运行数百或数千个进程，发电厂大概运行了40个过程，谷歌Chrome运行大约五六十或一百个进程，以此类推，等等，到目前为止我们所学到的，操作系统可以在可用的课程中多路复用这些。
今天我们要学习一点，也许它确实在单核之间进行上下文切换。
但是，即使它能够分离这仍然只有一个单一的记忆，使用一种我们称之为DRAM的硬件技术，你会在一些幻灯片中看到它被称为ram，这对单个核心意味着什么，这意味着操作系统上下文。
它实际上不会把东西从内存切换到磁盘，因为那样太慢了，我们上次介绍的是虚拟内存的概念，特别地，我们引入了页表的概念，它说每一个单独的过程都认为它有自己的30个，两位字节可寻址空间，至少在风险中，五个。
操作系统所做的实际上是转换这个虚拟内存空间，到相同的单个物理地址空间，每个进程使用一个页表，所以在这个页表中，你可以查找你的虚拟页码是什么，然后找到物理页码，然后用它来创建一个物理地址，地址到内存中。
或者你现在从这里访问一些东西，注意这里有两个地址空间，我们骗了你，从一开始，我们说过，你知道这个过程只有一个地址空间，不，在电脑里实际上有两个地址空间，进程运行时，其中之一是过程所需要的。
那是虚拟地址空间，其中之一是CPU或操作系统，实际上，操作系统转换为访问物理内存，所以从现在开始在课程的最后几周，当我们说地址，你要问我哪个地址，虚拟或物理，好啦，然后我们必须能够进行对话。
页表bel的作用，它真的把虚拟页码本身转化为物理页码吗，偏移量，字节偏移量是在相同大小的页面中，实际上或物理上，偏移量不会改变，所以这就是我们如何创建这些地址，我们会看到一个例子。
今天晚些时候我们将讨论一个例子，根据虚拟内存的工作方式，多个进程如何工作，每个进程一个页表，这允许操作系统保护进程彼此不受影响，将进程彼此隔离，我们还有这个额外的状态位，它发生在页表中。
您可以将此正确的保护位标记为，呃，允许多个进程共享同一物理内存，而不，也许互相写，所以你可以在这里看到，只有一口井，我有个小幻灯片。
是啊，是啊，你看看，所以你可以在这里看到，这里有一个共享页面。
其实有条纹，这是橙色和绿色的条纹，我知道这很难理解。
但这些都指向，或者至少是页表，对于这两个不同的进程都查找了相同的物理页码。
然而，也许我们只希望一个进程同时编写它，因此，我们会打开一个正确的保护位。
然后把另一个翻下来，这就是分享的理念，今天我们还是要暂停一下我们的怀疑，再想想，缓存不存在，它会让虚拟内存的事情变得更容易一点，下周一，我们将讨论这种重新引入缓存的方法，以及它是如何参与其中的。
但就目前而言，我认为每一次读取或加载数据的访问，或者存储或加载数据实际上直接进入内存，而不是某种SRAM缓存。
它去DRAM，可能会变成这样，所以我们来谈谈细节，页表第二部分完成，您可能想知道页面错误会发生什么，换句话说，如果我们必须一直到磁盘来加载我们的信息会发生什么。
记住这里的整个想法是页表意味着现在。
而不是加载所有三个两个字节，在DRAM中，每个进程都有三个两个字节的可寻址空间，我们一次将页面加载到内存中，有时我们可能需要加载额外的页面。
所以让我们来看看，其实还好，实际上我们还需要强调一点，也就是说，您可能想知道这些页表到底存储在哪里，我们知道页表可以让我们找出，内存或数据页在内存中的位置，但是页表本身呢。
让我们在这里做一些信封后面的计算，所以如果我们有一个3个2位字节的可寻址虚拟地址空间，然后我们在身体上有多少，我们有多少字节，我们有四个gib位，假设我们有物理页面的页面。
虚拟页面都是大小为4千字节的相同页面，这是什么意思，嗯，我们想弄清楚这些页表需要多大，记住页表是什么，每个虚拟页码有一个条目，计算页表大小的唯一方法，是计算出有多少条目，然后乘以每个页表项本身的大小。
那么在这种情况下，我们有多少虚拟页码，如果我们有2到32位，假设2到3两个字节的虚拟内存，每页2到12字节，然后我们有两个到二十个虚拟页码，好啦，这是页表中的条目数，您可能想知道页表中有多少信息，就像。
那包括什么，我们在上一张幻灯片上看到了一些，包括物理页码，它包括一些状态位等等，按惯例，至少对这门课来说，可能会说，可能每个页表条目有四个字节，所以对于每个虚拟页码，这是我们可以查到的信息。
如果我们快速算一下，四个字节乘以二到二十是，呃大约是四实际上正好是四，也许字节，那么这意味着什么呢，嗯，这是关于点的，我们拥有的DRAM内存的百分之一，我们拥有的，这还不算太糟，每道工序百分之一罚款。
不过，请注意，这就像四个，也许字节，还记得我们上次看到的关于缓存的内容吗，我知道我说过缓存不存在，它们确实存在一点，这里的重点是它实际上太大了，不能用现金储存，那么页表存储在哪里，它们也存储在内存中。
现在呢，这里有一个警告，这意味着如果我们，如果我们的，如果我们的指令说，加载字，例如，我们实际上必须进行两次内存访问，我们去看看，我们去看看，我们再按一次按钮。
啊我们做到了，是呀，好啦，让我们检查这里的两个内存访问，每次我们执行加载字或加载字节或存储字或存储字节，嗯，首先，我们需要弄清楚我们在操作系统中，或者CPU需要弄清楚这对应于什么物理地址，记住加载字节。
商店的话，所有这些都将在这里使用虚拟地址，所以我们要查找页表，查看物理页码是什么，但是页表在哪里，在记忆中，这意味着我们首先进入内存查看页表，并找到物理页码，然后我们再次进入内存，进入数据页。
获得实际的单词，或者我们正在查看和读取的实际字节，如果我们在装货，所以这就是我的想法，它将花费两次内存访问。
不是最大限度地减少性能损失的最伟大的事情，一些我们可以做的事情，也许我们可以包括现金，哦哦，有趣的想法，但又一次，我们不是在谈论这堂课，但我只是把它包括在这张幻灯片上，所以当你在周一的讲座后复习它时。
会更有意义一点，好啦。
所以我只是想告诉你，这是页表所在的位置，因为它们也是信息，它们还需要在内存中访问，让我们谈谈页面错误，我说过我会的，我们现在谈谈，页面错误，或者当你试图查找那段记忆时，那个数据页实际上不在内存中。
但它就在这里，我把滑梯放好，过一会儿，但现在你要知道，包括每个页表项的右保护位还包括有效状态。
这表示位是否在DRAM中，好啦，所以如果它是有效的，已经在记忆里了。
可以访问该数据页，然后如果它是无效的，那么数据页就在磁盘上的某个地方，那是什么意思，这意味着对于试图从内存中读取某些读取数据的进程来说，如果那东西在磁盘里，它需要先把它加载到内存中，那需要很长时间。
我来读读幻灯片上的单词，所以分页错误意味着这个有效位无效，这意味着我们试图寻找的数据实际上在磁盘上，所以操作系统所做的是它实际上干预，我们会更多地讨论这个问题，一会儿它就介入了。
它试图将我们试图从磁盘访问的页面加载到内存中，以便它可以将数据从内存加载到处理器，好的，好的，但它是如何做到这一点的呢，嗯，记住记忆就像一个有限的空间，所以如果你的DRAM的所有页面都已经填满了。
它可能需要选择要驱逐的页面，我突然知道操作系统有点像房东，但我们很少谈论这个，但我们要用“它”这个词，那么这意味着操作系统选择这个页面，通常这是在某种软件中完成的，比如页面替换过程。
并将请求的页面从磁盘读取到DRAM，最后，它将数据读入或写入，最后做负载，好啦，这就是页面掉落时发生的事情，现在呢，这里有一个关于页面替换策略的说明，我再重复一遍，再说一次如果我们考虑。
有一个小弯弯曲曲的箭头在那里，如果我们考虑驱逐你的页面，记住我们不是在谈论缓存，但是我们应该从那里学到一些概念吗，就像最近用的，我们也许可以用那种政策，也许我们想用先进先出，也许我们想用随机的。
所有这些事情，所有这些都将在软件中决定，这些东西并不是由硬件决定的，因为事实证明，去磁盘实际上是一个非常非常长的时间，所以我们可以在软件中做很多这样的逻辑，当磁盘被访问时，在读取磁盘页时。
所以再来一次状态比特，到目前为止我们学到了什么，我们学会了正确的保护措施，这是为了共享内存并保护进程不相互重写，如果他们共享相同的页面，我们有一个有效位，它告诉我们数据页是否确实加载到内存中。
否则我们就得走到这一步，然后我们还有第三个我们没谈过的，但我们现在要谈谈，哪个是肮脏的部分，这意味着如果页面上，如果页面如此，如果钻头开着，那么内存上的页面比这个页面更最新，你看看这个。
你就像，呵呵，我以前见过这种情况，我们今天不谈的是，丽莎一直在说的，那对我们来说有点熟悉，这是正确政策的一部分。
这个特殊的记忆需要做的。
我们谈谈吧，所以我们知道缓存是内存缓存，内存有点像磁盘的缓存，换句话说，记忆中的每一页，实际上是这个东西的秘密副本，只是离处理器更近，所以处理器实际上可以读取它，但是，考虑与缓存相同的情况，也就是说。
如果我们写一些东西，如果我们编辑一些东西，那我们是不是应该在缓存上编辑它，并立即在内存中编辑它，这样就可以通过，或者我们应该回信，所以在缓存上编辑它，让它成为最新的副本，一旦那个块消失了，更新内存本身。
这就回来了，那么你认为我们应该做哪一个来记忆，当我们有一个页面，当我们更新内存中那个页面上的信息时，我们是不是也应该在磁盘上做一个右，或者我们应该马上回去，当页面被驱逐时，我知道观众中有些人。
你们觉得谁说的很有趣，这里有几只手，谁说右后卫有趣，这里还有几只手，呵呵，我们该怎么做呢？我们是不是应该，也许不是当你可以谈论一点点，这里有一个简单的方法来思考什么是正确的政策。
这也是我们拥有记忆的原因之一，记住这里巨大的内存层次结构，我们想尽量避免去磁盘，然而，磁盘是非常有用的，因为与内存相比，它就像是一种无限的存储，但我们想尽量避免去那里，如果我们有一个程序。
不断地编写和编辑东西，然后它会改变缓存很多，很可能会大大改变记忆，我们希望它也经常更换磁盘吗，当我们做正确的通过，好啦，我听到我听到一个响亮的不从像一个人在观众，是啊，是啊，有趣的想法。
所以这里的答案是，也许虚拟内存应该使用，因为这些过程耗时太长，是啊，是啊，有个问题，奇妙的问题，所以这里的问题是嘿，有这样的页表，记住，上次丽莎对页表大做文章，不是缓存。
就像它只是一个页码和其他东西的查找表，好吧，就在后面，就像页表一样，关于像这样的数据，这是怎么回事，非常非常好的问题，这是我们稍后要讨论的。
但如果我们回到页面错误，这里的信息真的很快，当我们在页表中查找东西时，引发页面错误，假设有效位是关闭的，我们需要进入磁盘，操作系统要做什么，它不仅要从这里检索数据页，它还会更新页面错误，我是说页表本身。
因为页表就像是关于每个，呃，每个虚拟页面所在的位置，不管是记忆还是只是这样，我们总是要对页表进行更新，但我真正想问的是，数据的更新发生在哪里，如果你在商店工作，这里的想法是，是的，对于数据的更新。
您可能希望只在内存中执行此操作，所以内存更新，或者说哪个内存到内存更新了什么，我们有，我们有页表更新要关闭，我喜欢打开有效的部分，因为现在它在记忆中，不管怎么样，然后现在我们还希望能够更新到任何信息。
就在这上面，这就像我，我就像我在这里疯狂地走着，但是是的，所以如果我们加载信息，因为那东西在磁盘上，然后我们更新页表，如果我们把数据从内存中取出，因为我们需要空间从磁盘加载更多信息，然后那个阻力。
我们也许应该做一个右后卫，好啦，所以我们总是在页面存储库上进行磁盘访问，但那是为了加载信息，是啊，是啊，问题，是啊，是啊，这里还有一个问题，是啊，是啊，哎呦，是否有某种现金一致性是个好问题。
我们星期一再详谈。
所以现在我们都在谈论理论层面，我要再介绍一个理论概念，然后我们要练习追踪记忆，一点点看看到底会发生什么，原来页表的整个想法，这个页表有虚拟页码的所有可能位置的巨大查找，对于一个过程，那还不错。
但是一旦你有很多很多的过程，你的坡道里只有很多很多的页表。
那占了很大的空间，而且有点浪费，所以我将介绍分层页表的概念，这就是页表的使用方式。
如今，您还会听到它们被称为多级页表，这就是为什么在这里包括这两个主题，我都看到了，呃这两个术语，所以让我们回到我们的页表条目有多大的想法，有多大我们的页表有多大，如果每个页表条目是四个字节。
这些是与上一张幻灯片相同的计算，所以如果我们有一个3个2位字节的可寻址空间，就像那是我们的三位一体的电脑，例如，我们有四个gib位的内存，我们有四个cubit大小的内存。
那么我们拥有的页面虚拟页码的数量，还是要到二十岁。
这和我们在上一页看到的计算是一样的，每个条目的页表大小是4个字节。
也许是一点点，仍然会是那个点，我们之前看到的百分之一，但是，因为每个程序或进程都需要自己的虚拟或自己的页表，如果我们有256个过程，对于我们的现代计算机来说，这实际上是一个非常小的数字，但请原谅我。
然后是256个过程，每一个都需要自己的页表，目前我们相信所有的页表都存在内存中，因此，要处理这256个进程页表，页表值多少信息需要在内存中，一个吉比字节，好啦，二到八次，二对二二，所以突然间，我们有2。
5%的珍贵记忆被利用了，只是为了页表的后勤信息，它似乎不太有效率，因为你记得我们刚刚争论了很久，好啦，当我们回到磁盘，我们必须正确地加载数据页面，我们想喜欢，避免加载太多的数据页在移动。
内存中的数据页太多，那么我们如何保持这种后勤记忆，这有点像页表内存，向下的问题。
这里还有一个复杂的问题，你们中的很多人可能会说，你为什么不把那些页表放到磁盘上，那就没问题了，好吧好吧，事实证明，您不能将整个页表交换为，就像你不能喜欢，否则你就会喜欢，就这样去吧，为了阅读东西。
你实际上必须从记忆中读出它，所以每次你想加载页表，你必须一直把页表加载到内存中，稍微读一下，然后可能把它驱逐回磁盘，在这里需要很多信息，好啦，所以需要有一个更好的方法来存储最喜欢的。
关于我们页表的最珍贵的信息进入内存，然后把剩下的放在这个地方，输入页表层次结构，这有点像这里的页表多元宇宙，其实有一点，我不看漫威，所以也许这是不对的，呃这里有个类比，但如果我们把页表，好啦。
这又是多层次的想法，那是什么，这里的关键问题是什么，我们的页表太大了，他们一个过程就可以了，一旦您有多个进程，它们只会占用太多内存。
如果我们执行以下操作呢，所以我们在左边有DRAM，然后我们在右边有光盘，在左边，我们将有一个一级页表和几个二级页表，这个一级页表有什么，它有一些二级页表的物理页码，可能在记忆中，或者他们可能一直在这里。
这就是多级页表层次结构所做的，以下是之前的洞察力，我谈论这里发生的事情的细节，这里的洞察力是我们的许多程序，你可能也写过很多这样的东西，即使我们有两个到三个两个字节的可寻址内存。
我们可能没有使用所有的2到3个2字节，我是说我们已经知道了，但我只是重复给你听，这意味着我们访问的页面，我们访问的页面并不多，这意味着我们访问的页表条目，我们需要访问的页表条目也不多，所以说，因此。
虚拟地址空间的稀疏性意味着，我们将只访问页表条目的一个相当小的子集，当程序运行时，因此，我们执行以下操作，我们做这个分层或多层页表，一级页表，抬起头来，它们在内存中的第二级页表。
然后第二级页表查找内存中的数据页，记住这个二级或那些二级页表，那些数据页--它们可以在内存或磁盘中，所以现在我们有了第二级页面，它们可能在磁盘中，但我们真正关心的是我们的数据。
我们正在积极访问以加载和存储我们的数据，当一级访问出现页面错误时，然后将二级页表从磁盘加载到内存中，这就是多层页表层次结构的思想，是啊，是啊，有个问题，哎呦，所以一级页面也有自己的驱逐策略，是啊，是啊。
又是好点子，我们将谈谈驱逐政策是如何运作的，就目前而言，只要暂停你的信仰，假设所有第一级的页面都在内存中，对于正在运行的所有进程，我们将讨论一些事情是如何改变的，下一个下一个，星期一，是啊，是啊。
但现在只需假设第一级页面总是需要在内存中，第二级的页面是可以被传呼的，在内存中进进出出，所以每当你有一个活动的过程。
第一级页面总是需要在内存中的某个地方，但让我们来看看，这就是风险，风险5，3，2或c，rv，3，2，我根据它为这个多级页表层次结构定义的内容工作，以前我们有3个2比特的虚拟地址。
排名前二十位的是虚拟页码，现在我们说虚拟页码实际上是两个不同级别的虚拟页码，好的，好的，这里的顶层，最上面的。
最上面的十位将是我们第一级的页码，中间的10位是我们第二级的页码，然后这里的所有页面都将是大小为2到12字节的，这就是在这里结束的偏移量，所以这意味着以下内容，这又回到了刚才问的问题，这没关系。
对于特定的过程，这里到底发生了什么，CPU有一个特殊状态寄存器，调用页表寄存器，它实际上被称为sptbr，我们稍后会看到缩写，但是这个页表寄存器是进程的一级页表的地址，现在。
这指向内存中某个地方的第一级页表，这个一级页表有什么，嗯，它有任何二级页表的物理页码，或者它说你知道你需要去磁盘，因为这实际上是磁盘地址本身也有状态位，这里有多少参赛作品，二到十的入口，好啦。
那么为什么会这样呢，或虚拟页码在此引用，一个索引的大小是10位，所以这意味着我们有可能找到两到十个，所以我们需要有一个页表，可以为这两个人服务到十个人，所以这就是我们所说的，这里最上面的十位。
那就是那首曲子，十是从，这些条目中的每一个都指向某个二级页面，或者对不起，推荐人，一些二级页面物理页码由二级物理页码，其中一些在这个，其中一些在记忆中，那么每个二级页表都有什么，它现在也有物理页码。
但现在是数据页，那么这里有多少条目，我们考虑一下这些二级页表的寻址或索引是什么，就是中间这十位，那么有多少条目是可能的，也是二到十，这就是我们所拥有的，好啦，注意这里有两组10位，这让我有点困惑。
这就是风险所在，五个ISA说，所以这就是为什么，但你可以看到这是两组不同的，到了这个水平，一个人说，在所有可能的索引中，我有十个一级索引中的两个，因此这就是，这就是我的第一层桌子需要有多高。
我们的二级页表，好的，两个指数，还有十个可能的指数，因此，这就是页表需要有多高，最后是数据页，这些是二级页表引用的，现在这些数据页是什么，嗯，它们的大小都是2到12字节，因为那是页偏移量。
这些物理数字存储在页表中。
让我们做一些数字，我知道这就像，又是一个非常密集的讲座，就像我说的，呃，我认为虚拟内存可能是这门课上最具挑战性的事情之一，因为有太多的细节在飞来飞去，所以让我们再做一些信封后面的计算。
我提出了分层页表的想法，和那种多层次的页表，说我们节省空间，在页表内存占用的排序中，但我们能节省多少空间呢，我要让你考虑一下，所以让我们假设我们有和以前一样的电脑，页表大小4字节，所有的好东西。
现在让我们运行16个进程，如果我们没有任何等级制度会发生什么，所以我们只有一级页表，所有那些第一级的页表都必须在坡道上，如果我们有这种风险会发生什么5 32页表硬层次结构，因此。
所有进程的第一级页表仍然需要在RAM中，但现在第二级会在别的地方，那么一级足迹是什么呢，我给你一分钟考虑一下，然后和你的朋友谈谈，我们会回来的，去你的粉丝，好啦，所以我要用一个小笑话打断你们。
那完全没有关系，但我想可能是周三。
所以我们可以谈谈，什么，你怎么让章鱼笑。
我不知道，你怎么让章鱼笑，你们听说了这是我的最爱之一，你给他们挠痒痒十下，是啊，是啊，不是哈哈，是啊，是啊，它与虚拟内存完全无关，但是你知道，我以为，这是一个让我们回到观众面前的好方法。
所以让我们稍微讨论一下，多级页表在第一级给我们带来了多少。
在正常情况下，所以在多级页表之前，在所有的等级制度之前，我们有多少一级或多少常规页表，嗯，我们需要计算它们自己的页表大小，这里的第一部分，前三颗子弹是我计算的四颗，也许又是字节。
但我已经把它包括在这里了，那我在这里做什么，我想说的是，好啦，电视有多大多少页，我有多少虚拟页码，因为这告诉我我的页表有多大，有多少页表，我只有一个办法，想想我用什么寻址方案，在这里进行虚拟地址转换。
我知道如果我们有四个立方体字节页，我们需要两个到十二个字节，否则一切都会好的，二到十二字节，是四个QB字节页，然后我们需要12位偏移量，在三个二位空间的可寻址部分。
然后所有其他20位都将是我们的虚拟页码，因此，我们的页表大小将是2到20位，页表项的页数，我们有几倍的大小到达每个入口，那是两个字节的二，或者常规片段中的四个字节，所有16个进程都有这4个字节表，因此。
这意味着平均是64，也许字节，所有这些进程只是为了存储它们的页表，其中很多可能会参考正在下降的页面，甚至没有被使用，另一方面，我们的二级版本现在给了我们什么，这是我们的二级风险五级版本给我们现在很好。
让我在这里调出上一张幻灯片中的地址翻译，这告诉我们我们的城市到底是哪十个比特，每级有多少位，你也可以计算它，并自己计算出一些逻辑，但现在让我们考虑一下，如果我们只考虑第一级页表和那些。
第一级中的每个页表都将有可能的条目数，或两个到可能条目的数量或数量，可由我们的一级指数调整，那将是十到十个条目，他们每个人，在这种情况下，我们继续假设有四个字节，这将包括物理页码。
任何形式的状态字节或状态位或任何东西，这意味着2到12字节的页表，我们有多少张页表16张页表，所以现在我们突然到了64岁，肾字节，我们落后了一千倍，我是说在1024年，那很好，作为，如此突然。
我们避开了我们的足迹，我们需要保存在内存中的最小页表数，为了让这16个进程现在都能运行，是呀，的确，这个分层的行会有一些页表，和二级页表，不过没关系，至少就脚印而言是记忆，足迹，我们太小了。
我们可能会慢一点，但至少我们更有效地利用了记忆，这里还有一个练习给你，我说他会翻译，然后呢，哎呦，这里有个问题，是啊，是啊，什么事？所以有一次有个问题，问得好，问得好，问题是嘿，好像我真的不明白。
如果喜欢为什么这个基本，喜欢原创页表设计，就像我们不能只是喜欢商店，页表的一部分，这是个很好的问题，呃，就本课程而言，我们要说就像，我们在这里使用的抽象，页表能够成功地查找所有虚拟页，就像，打扰一下。
是否能够成功地将所有虚拟页码转换为物理页码，或者告诉他们或者告诉我，所以我们不想让事情变得，页表级别的遗漏，我们想，至少能够回应关于，我们要找的这个页面是否真的存在于内存中，因此在这里，呃。
在这个原始示例中，因为我们有2到32位可能的可寻址空间，我们会有两到二十页，我们需要能够说出20个虚拟页面中的所有这两个，该物理页是在内存中还是在其中，这有点像这里的抽象之一，你说的就像是。
我们不需要记忆中的所有信息，在这里，Risk Five使用的一种方法是使用这个分层版本，也就是说我不能，或许可以查一下，我关心的所有数据的物理地址，但我会查看页表各部分的物理地址，我在乎的。
这就是为什么我们有这个等级制度，所以我们有这个等级制度说好吧，这个第一级页表告诉我所有第二级页表，我目前正在和，所有的身体，就像虚拟页码到物理页码，我目前在这里工作，他们都在这个一级表中跟踪。
那你说的就是，这就像我正在处理的实际数据，那些查那些记忆页，它们由这些二级数据表管理，所以这里只有一点点头顶，允许这种额外的间接性，但它实际上节省了CPU，它为操作系统节省了大量的查找时间。
它只知道我可以查这个然后查这个查这个，最后你可以从这里加载东西，我很乐意多回答一点，但希望这至少能让你开心一点，因为我觉得你说得很对，再来一个翻译演示，我们不打算这样做作为一个好的。
我至少会给你一些时间来处理，所以我们有一个虚拟地址，假设我们有以下地址，我想那是三块二。
好啦，我们这里有以下地址，我们怎么翻译这个，如果我给你下面的页表，我假设所有这些页表都在内存中，还有其他的在磁盘里，但你怎么把它翻译成一个物理地址，你可能需要半分钟来处理，幻灯片上有什么。
美丽的父母不是超级美丽的标志，你知道吗，有时候声音会让我有点紧张，这是其中之一，这是其中一次，但我也告诉过你，所以这也是我的错，所以让我们谈谈，那么我们要做什么，我们从这个32位的虚拟地址。
我们正在努力翻译它，与此虚拟地址相对应的物理地址，这就是我们的目标，我告诉过你我们有一种分层的方式来翻译地址，然后我给了你一些查询表，对于层次结构中的每一部分，那么我们如何进行得很好呢。
我们可能想做的一件事，从这个3位2位的地址开始，好啦，告诉我Lone查找的前十个部分是什么，一级查找是，然后中间的10位是什么告诉我L 2查找是什么，等等，等等，所以我要在这里做，那么我做了什么。
你就像，我怎么得到这个我喜欢，其实呢，当我翻译虚拟内存地址时，我喜欢从下面的部分开始，因为通常这里的偏移量是很好的倍数，所以在这种情况下，较低的12位或3个十六进制数字，那是我的页偏移量。
不会是十六进制四五零，只要下三个十六进制数字，中间的10位相当于两个半文本数字，好啦，那么这与这里对应的是什么呢，那将是两个。
使用这里的指针，那将是两个，那是一个完整的十六进制数字，零是另一个完整的十六进制数字，然后这个4的下两位是零。
好啦，所以中间是零，零二，最后这里的最后十个位是四个位中的上位，哪一个是，然后是零，然后是零，那就是x 1，好啦，所以这就是，这就是翻译。
至少要弄清楚我们有什么指数，现在我们可以回到这张桌子上，所以现在我们知道了我们要查找的条目和一切，我们要去查查，好啦，那么我们在这里的查找是什么，也许我应该改变其中的一些。
我要把这里的地址改一下，因为看起来有点吓人，十六进制一，我要把这个地址改成，就像一个疯狂的地址，因为我不想，我不想让屏幕上的两个把你弄糊涂了，所以好吧，我们开始吧，所以我们现在在这里，这篇课文是什么。
一个索引指的是这个十六进制的，这个级别，一个指数指哪个条目，我们应该看看一级桌。
所以我们不看第零项，我们不看牙齿的入口，我们看一次进入，所以我们就在这里，在行的实际索引本身，然后这个条目是什么，比如这个页表里的信息是什么，这个十六进制二零一或其他什么，那是物理页码，二级页表。
所以这是这里的箭头，这里好像有些信息，就像，你知道物理页码，不知何故，你需要把它转化为实际的，像三个二位需要是二级页表的物理地址，但这就是我的想法，这篇课文二零一大致是，呃。
在第二级页表开始的抽象级别上，现在我们有了这个二级指数，好啦，所以这个十六进制0 0 2，我们如何利用这些信息，我们使用它的方式是一样的，所以十六进制零二，这告诉我，我应该看第二级表的第二行索引。
我现在在看，所以我看着这个，这个入口就在这里，也就是十六进制六十，好的，好的，这就是信息，那是物理页面，我应该查看的数据页的编号，这就是所有的信息，我需要能够创建物理内存地址的物理页，我们去看看。
物理页码是多少，它是该级别数据的物理页码，两页第二页，不会是十六进制六十，物理页面的下12位是什么，物理地址，这将是页偏移量，原始页面，与虚拟地址的偏移量，我们试图翻译，所以现在是十六进制450。
我把它们连接在一起，因为我有三个二位，在这种咬伤的情况下，物理内存的可寻址内存，那将是十六进制零，我只是在这里把它们砸在一起，这些是较低的十二位，这是上面的二十位，我为什么要走过它，如此缓慢，我再想想。
虚拟内存，所有这些疯狂的翻译都在发生，我希望一个完整的例子能有所帮助，所以在过去的五分钟里，当然啦，我要谈一件事，你们很多人像我一样单独问，你就像他们在教室里走来走去，你就像你看到的，你好像少了一分。
然后每个人都像现金一样，下次我们将讨论缓存，但还有一点，我还没有谈到操作系统提到它，但现在您可能想知道页面错误实际上是如何工作的，就像这里到底发生了什么。
开始这个对话，我可能不会完成它，我们星期一再详谈，但这里有一个想法，错误和所有这些类似的，你知道的，在这一点上，我们一直在说操作系统会处理一堆东西，但操作系统必须以某种方式处理这些东西。
它本身就是一个软件，这本身就是一个过程，它还必须以某种方式使用CPU，那么对操作系统的高级理解是什么呢，这将允许操作系统进程与所有用户进程共享CPU，在请求记忆，然后就像做所有这些事情。
请求网卡，所有这些东西，答案是这里有两个关键特征，其中之一是CPU以两种不同模式执行的可能性，主管和用户模式，另一个是异常在这里的实际工作方式，主管模式与用户模式，想法是这样的，你有一些CPU。
或者我们从项目三开始就一直在建造的CPU，它可以执行任何，它给出的任何指令，它没有任何类似的东西，啊，我不能执行这个指令，只要是有效的指令，它会尝试执行它，但如果这就像一个流氓过程呢。
CPU只是盲目地访问东西，是啊，是啊，或者执行东西，但CPU说的其实就像，好啦，嗯，你不能进入，你不能看到记忆的所有部分，否则你不能做这些特定的事情，如果你处于所谓的用户模式，如果你是主管模式。
或者我们所说的内核模式，有时做这些事情是可能的，那么什么主管模式，这是一个，这是一个特殊的注册身份，有点说这个这个过程，这个特殊的过程可以执行这些类型的指令，它可以将约束强制到其他进程中。
就像超级用户一样，对于许多熟悉Linux系统的人来说，但这是在硬件层面，这种硬件主管模式经常，如果这里有例外，你会得到一个蓝色的死亡屏幕，你会发生疯狂的撞车事故。
那是什么意思，这意味着大多数东西实际上是在用户模式下访问和执行的，包括内核的很多部分，操作系统本身的许多部分，硬件主管模式使用得很好，很少，它用于从磁盘进行内存访问和页面加载，这里是它使用最多的情况。
就是这种例外和中断的想法，下次我们会更多地讨论中断，所以我只想，我想把这个幻灯片，两天内可能会有两次，下周三左右，但让我来谈谈这里的左手栏，异常异常是操作系统喜欢的方式，干预当前程序的执行，好啦。
所以这是同步发生的，例如，如果有一个非法的指令，当你想通过数据路径，突然间你解码了一些你喜欢的东西，他们就像，我不知道这看起来有什么异常，然后如果你只是想停止这个程序，它就在那里，可以除以零异常。
你可以像我喜欢的那样页错误异常，我不知道数据在哪里，帮我帮我操作系统，这就是允许用户进程使用此异常思想所做的事情，用户进程试图去流氓异常，这就是这就是一般的思想。
这是如何通过陷阱处理程序处理的，这是今天的最后一张幻灯片，我们下次也会更多地讨论，跟踪处理程序实际上是处理这些异常的东西，这是一种术语，我是说。
嗯，这绝对是术语，但我的想法是，假设你有那个页面错误，现在呢，操作系统需要接管，以便能够加载页或将所需的任何页从内存驱逐到磁盘，然后将页面从磁盘加载到内存中，所以操作系统在某种程度上需要控制过程。
那么发生了什么，你冲水，您在故障指令之前完成所有指令，记住我们有一个管道，所以事情还在执行，在未完成执行的指令之后的其他一切，然而，没有行动，做泡泡类的事情。
你知道管道危险的东西，它回来了，告诉操作系统做它的事情，操作系统在监督者模式下完成它的工作，把书页带回来，所有这些事情，然后返回到原始指令并重新执行它，好啦，那么我们下次要讲的是。
我们如何从用户过程的角度保持这种抽象级别，事情可能需要更长的时间，但过程不知道，感觉就像顺其自然，它的指令突然隐藏异常，我就像没事一样，我让操作系统来处理，在这里等着，在这里等着，至少，这就是。
你知道的，这就是用户进程的想法，然后继续走下去，如何工作留待下次，星期一见，祝你们周末愉快，谢谢你，嗨问题。
P45：Lecture 34： VM III： TLB - 这样好__ - BV1s7421T7XR
大家好，欢迎来到61 C，我没有反应，因为我们用的是网络研讨会，不过没关系，我相信你们都非常兴奋，所以今天是星期一，但在我们开始常规的61 C之前，我确实想记下，呃，加州大学范围内的罢工确实开始了。
这是一次罢工，本科，Gsis，呃，其他学术秩序，工人，实际上，就像超过四分之三投票的人，我说四分之三的工会投票，有百分之九十，所以这就像，那是一个很大的数字，嗯，投票是因为，工会已批准罢工。
在工会之间没有协议的情况下，他的代表是，呃，UAW和UC在学术工作者等问题上，薪金福利，工作保障和对在职父母的支助，在许多其他的东西中，现在在61 C，我们给了我们一些时间，呃。
我们的员工决定他们想做什么，也让我们想出如何支持这门课，在没有工会的情况下，因为这堂课，就像加州大学系统中的许多其他东西一样，是真正依赖于劳动的，尤其是，这个工会的劳工，所以试图弄清楚该做什么。
试图承认和尊重，这就是为什么我们今天要开一个关于变焦的讲座的原因之一，所以随着时间的推移，事情可能会发生一点变化，但是为了更多的资源，请务必查看我们的广告帖子，我们会发出更多的更新，随着局势的发展。
希望明天，但考虑到这一点，让我们来谈谈虚拟内存，因为即使我是说校园里发生了这么多事情，我们也在考虑我们电脑里发生的一切，所以上次，我们对虚拟内存进行了超级超级深入的研究，有层次结构的页表之类的东西。
多级页表，这一次，我们要退一步，思考一下我们如何以一种方式实现虚拟内存，它和我们其他的操作系统一起工作，呃，这与我们在过去两年里一直搁置的缓存有关，两堂课左右，所以事不宜迟。
我们将继续我开始的关于异常和主管模式的讨论，所有这些我们都将有一个录音部分，我只是要跳过，超短的，就像五分钟。
但我想为了节省时间，我们要跳过它，然后我们要看幻灯片上的其他内容。
所以考虑到这一点，上次我们在哪里，好吧，上次当我隐藏浮动会议控制，上次我们考虑过这种处理者，那是什么意思呢？陷阱处理程序是一个允许，可能对每个人来说，好啦，我们走吧，呃。
陷阱处理程序是一个允许维修这些东西的东西，调用中断和异常，在硬件层面，但实际上，如果你有一个过程，或者我是说一个过程，我们称之为，从操作系统操作的程序，观点，如果您有一个使用CPU的进程。
有时你想改变这个过程，也许可以通过另一个过程来工作，或者你可能想处理一些错误，我们简要讨论过的两件事是中断和异常，两种不同的，这两件事的区别是，事实是中断与程序是异步的，他们是程序之外的。
所以如果你喜欢，按键盘上的一个键，或者你稍微移动一下鼠标，然后单击当前进程之外的内容，那正在发生，例外，另一方面，与您的进程同步，所以这通常是你的过程正在执行的东西，执行，然后发生了一些事情。
它需要有一个例外，调用异常，还有这个，例如，就像如果过程工作在进行，然后可能是它引发了页面错误，或者它有一个不正确的无效指令，在这个过程中。
不知何故，它需要退出，呃，从那里开始，现在陷阱处理程序是如何工作的，原来这里有几个维度，有几步，所以我现在就把一些放在页面上，它完成了之前的所有指令，引发我们所说的故障的那个，或者中断，或者例外，好啦。
陷阱手柄就像困住故障一样有效，好啦，这就是为什么它被称为陷阱处理程序，一旦完成，或者一旦它让处理器，CPU完成所有指令，然后它刷新所有未完成的指令，或者发生在错误之后，所以有两类指令。
在错误指令之前发生的事情，错误指令之后发生的事情，其中很多可能是不完整的，我们考虑之前发生的一切，然后说，好啦，你们都提前完成了，然后其他还没有完成的事情，在错误指令转换为，让我们说像一个没有行动。
因为它被冲走了，所以这与管道危险非常相似，我们把CPU冒泡出来，清除CPU以允许其使用。
然后发生了什么，然后陷阱处理程序开始运行，好啦，所以陷阱处理程序是一个过程，那就是用CPU的东西，它运行在主管模式下，好啦，这就是这里的想法，为什么我们有陷阱处理员，我们想为这些类型的事情服务。
比如中断和异常，而这一切，但我们喜欢你想要中断的一个主要原因，唯一的例外是发生了一件特殊的事情，当前以用户模式运行的处理器可能无法处理，所以它想调用主管模式，或者它希望硬件处于监管模式来访问特权内容。
现在陷阱处理程序以监督模式运行，处理指令，处理异常，然后呃，打断我们的开始，然后它可以选择返回到原始程序，然后重新执行错误指令，所以我有了这个想法，也许如果你按下你想激活的键。
就像操作系统需要处理所有的设备处理和东西，然后它需要返回到当前的程序，好啦，是啊，是啊，那把钥匙，那个键现在被按下了，我需要读取密钥中的数据，所以从程序的角度来看，在那段时间里一定看起来什么都没发生。
所以让我们更详细地看看这个，下面是一些例外的例子，所以我的意思是，再喜欢一次，这种打断的想法，我们星期三再详谈，当我们谈论木卫一的时候，但是如果，关于例外，下面是风险5中的几个例子。
您如何知道您有哪种类型的异常，假设陷阱处理程序开始，就像没事一样，我在这里该怎么办，它将查看哪条指令是错误的。
还有它在管道中处于哪个阶段，例如，假设有一个指令。
呃，假设有一条指令触发了一个异常。
在指令提取和指令解码之间很好。
因为它不是管道阶段，陷阱处理人员会像，好啦，嗯，它可能是一个pd是一个pc地址异常。
或者在指令解码和执行之间进行选择。
可能这里触发了一个异常。
然后轨道板就像，好的，好的，让我看看这个说明书，让我来看看这个事实，它介于id和ex st之间。
啊，可能是非法操作码，然后它会做一些其他的事情，以此类推，所以这是一些可能发生的例外的例子。
现在陷阱处理程序的一些细节。
就像我们说的陷阱面板会试着，完成运行的所有指令，然后能够开始自己运行，就像，然后很好地保存故障指令，让我们稍微考虑一下，那么旅行者擅长什么呢，首先，它保存当前程序或当前进程的状态，因为再一次。
它可能想晚点再回来，所以它需要保存所有的寄存器，程序计数器和其他东西，我们稍后会更多地讨论这个问题，第二件事是它需要做的正是我们在第一面所说的，它需要像，好啦，我们该怎么处理，中断或异常。
我要知道是什么引起的，所以它会浏览指令，它会看穿它执行舞台的地方，它会，它会检查收银机，也许是为了看看情况是什么状态，然后在此基础上，它将处理异常，在它处理异常或中断之后。
它会做两件事之一，它可能做的第一件事是返回到最初的过程，返回到原始程序，事情发展到这个地步，这样做是为了恢复程序状态，保存的所有寄存器，然后它将把控制权交还给程序。
请记住陷阱处理程序在此特殊主管模式下运行，嗯，它需要在硬件中将整个CPU返回到硬到用户模式，然后程序现在将继续运行，它做的其他事情，这里有一张很酷的图表，也许或者我是说，当我画它的时候。
我觉得它是一个很酷的图表，但这里有一个很酷的图表，说明了真正发生的事情，一步一个脚印，如果我们把这些圆圈中的每一个都看作是执行的指令。
那么在程序的情况下，程序将运行前面的指令。
然后在当前的指令下，哦例外。
因此，CPU将把控制转移到处理程序的第一条指令上。
谁要跑啊跑啊跑，如果处理程序想继续执行程序。
它将返回执行导致故障的提取。
然后程序就会继续运行，等等，等等，好啦，所以这是陷阱处理程序可以做的一个例子，但让我们假设这是一个完全古怪的例外，就像可能有一个分段故障，也可能有一个像特权访问，程序不应该做的事情。
然后陷阱处理程序应该退出程序。
它是如何做到这一点的，它实际上就像终止程序一样，我说的这口井是什么意思，同样地，程序将运行前面的指令，运行当前指令，然后导致异常或中断，CPU要转移，或者CPU将把控制权转移到处理程序。
处理程序将运行它的第一条指令，下一个指令一直到最后，然后就会像，好啦，我不想再回去执行升天的命令，我想完全释放程序资源，呃等等，等等，然后现在也安排一个新的节目。
我只想在这里做一个关于释放程序资源的笔记，注意，所有这些资源都是硬件级别的，所以像嘿这样的事情，也许在DRAM中使用了一个页表，在某个地方，我知道这个过程不会再发生了，所以我要杀了它。
不是指苹果之类的东西，或者所有这些类型的事情，你知道我们想，做所有这些小指针的东西，突然间一切都好了，嗯，你没有时间释放所有这些在硬件层面上的东西，内存不会被覆盖，因为至少对于程序来说。
从CPU的角度来看，还是从，只是不会，它不会知道那个过程不再可用了，因此，记忆不能被其他人使用，聊天室里有几个问题，呃，让我试着回答他们，一号匿名与会者说，陷阱处理程序如何决定是继续执行还是终止程序。
这是个好问题，这在很大程度上是基于第二步，因此，确定是什么导致了异常或中断，基于此，假设是页面错误什么的，你所记得的，什么是页面错误，上面说这一页，我要访问的此数据尚未在内存中，所以我需要先去磁盘。
然后返回并重新执行这个加载指令或存储指令，所以现在它可以，现在该进程可以继续运行，所以这是由于知道是什么导致了异常，中断，是页面错误，当您尝试执行MEM阶段时，在那段时间里。
可能处理程序决定将上下文切换到不同的进程，我们稍后会更多地讨论这个问题，但希望这能回答你的问题，这在很大程度上是基于哪条指令导致了故障，哪个错误指令，以及它在管道中的位置，匿名与会者二号的第二个问题。
也可能是同一个匿名与会者，呃，那是呃，我例外吗，这里是负1，完全完成，流经管道，处理程序处理异常之前，这也是一个很好的问题，我们简短地讨论了这个，但我要再重复一遍，所以是的，所以这样想。
如果我回到以前的幻灯片，如果它让我这么做，是啊，是啊，如果我回到以前的幻灯片。
这样想吧，让我们说呃，我们就在这里。
然后指令，错误指令触发此非法操作代码。
所以根据非法操作码，可能诱捕员决定，呃。
彻底扼杀程序，在这种情况下会发生什么，记住管道是如何工作的。
即使指示，故障指令当前正在指令解码阶段执行。
所有这些阶段都执行MEM，这些都是由发生在错误指令之前的指令占用和处理的。
所以这些都会完成，所以陷阱面板会让他们完成。
然后陷阱处理程序在状态下也会做同样的事情，然后想出把手。
例外，然后返回或终止程序，好问题好问题，好啦，所以呃，实际上是匿名与会者，第一个说还好，嗯，就像，陷阱处理程序会发生什么。
我在我阿姨的回答中提到了一点，我只想在这里多说一点，上下文切换的想法。
我们以前见过这个短语，但我想提醒你，它是上下文。
当你有多个程序同时运行在你的cpu上。
但同时从人类的角度来看，CPU只能喜欢单核。
CPU一次只能有一个进程在其上运行，操作系统所做的就是迅速地把它们交换出去，比如用一个新进程快速交换当前正在运行的进程。
它通过在高水平上改变处理器的内部状态来做到这一点，这到底涉及什么，如果您有多个like对quote反quote同时运行，呃，系统会设置一个定时器，可能在10微秒的水平上。
就像时钟周期空间中非常非常长的东西，但在人类空间里很短，当它到期时，它的性能是硬件中断，好啦，为什么我们要处理，这里硬件中断，因为当前的流程就像运行，然后突然从外面的操作系统就像，没有，对不起。
得开始下一道工序了，然后它的作用是，它的作用是因为它是一个硬件中断，它触发了一个陷阱处理程序，然后陷阱管理员说，哎呦，我在做一个上下文切换，我该怎么做呢，我将保存所有寄存器值，包括当前进程程序计数器。
以及我们所说的页表寄存器，这是活动进程页表的内存地址，还有其他各种寄存器，好啦，所以又喜欢了，我们想要什么，我们因为上下文切换，理想情况下，我们希望切换回当前的过程，为了让我们做到这一点。
我们需要保存所需的所有信息，这样我们就可以喜欢，呃，我们可以，我们就可以精确地，有了这些，呃，有了这两个项目，你可以，你可以想象程序计数器，那是指向当前指令的，这是当前正在运行的指令的地址。
或者下一条正在运行的指令，打扰一下，然后页表寄存器，这是页表现在在内存中的地址，还记得上次我们说的那些话吗，或者像前两次我们说的所有关于操作系统的东西，不会把东西从内存中冲走，因为那样会花很长时间。
所有这些陷阱处理人员正在做的事情，保存状态全部在CPU，像寄存器是超级超级快的，记住了，这是什么意思，这意味着所有同时运行的当前进程，你知道像再次，有了这个，所有这些上下文切换之类的。
所有这些当前活动的进程都在DRAM中，它们将继续在DRAM中，直到程序或进程终止，所以通过这样做上下文切换，就像，呃，只需更改页表，就可以为不同页表的另一个地址注册，我们不必担心改变页表本身。
或者换掉页表，所有的页表都留在那里，陷阱处理程序所做的唯一一件事就是切换出寄存器值，好啦，所以这就是，这就是上下文的力量，有一个定时器硬件中断发生，但是有两个人，非常重要的寄存器，程序计数器。
页表寄存器，允许下一个进程继续执行，甚至是继续执行的当前进程，没有任何变化，也没有任何想法，他们曾经暂停执行，所以还有另外两个部分，呃这个部分，只是讲了一些例子，好啦，所以实际上好吧，所以上下文。
这是陷阱处理程序现在如何工作的一个例子，让我们谈谈第二个例子，那是页面错误，什么是页面错误，我们已经谈了一点，但这里说页表有有效位没有设置，因为数据不在DRAM中，数据页实际上在磁盘的某个地方。
那么陷阱处理人员需要做好什么，陷阱处理员就像，好啦，我在处理什么样的例外，它就像看着指令一样，它看起来像它所在的地方，也许它看其他州，然后它说，好啦，这是假设这是一个页面错误，所以我需要处理这个异常。
如何处理此异常，嗯，我需要从磁盘上读出那一页，所以启动磁盘，我们要讲一下输入输出，下次它可能会更新任何页表，它可能需要进行上下文切换，因为磁盘记忆需要很长时间才能访问，所以也许在这段时间里。
从磁盘上抓取东西，它只会说，好啦，嗯CPU，你现在什么都不用做，所以请开始运行另一个进程，或者像继续运行一个不同的进程，等磁盘好了我再来找你，然后跟着页面错误，呃，陷阱处理程序决定重新执行指令。
以此类推，等等，打扰一下，这里的一个附带说明是，还有其他涉及内存的事情可能会导致异常，其中之一是侵犯权利，我们来谈谈到底是什么类型的，在今天的课程结束时，轨道处理程序是如何处理这些事情的，好啦。
我们将要讨论的第三种应用。
或者陷阱处理程序的例子是这个叫做系统调用的东西。
现在呢，系统调用有点混乱。
因为它们通常被称为软件中断，这可能是你更习惯的短语，我在这里看到了Sycall，就像程序从操作系统请求服务一样，好啦，类似于函数调用，只是它需要某种主管模式的东西，例如，呃，创建和删除文件。
访问外部设备，执行printf或malloc，所有这些类型的事情，甚至启动一个新的过程本身，注意这里我强调了这个e调用，你以前在项目2中见过这个，E的电话实际上是在做，就像。
实际上是要求陷阱处理员做一件事，所以现在你又回到了打印的事情上，然后你必须提前设置论点，是啊，是啊，这里也一样，它是一个叫做。
但它是由内核执行的，让我们来谈谈最后一点，这启动了一个新的进程，再说一遍，这是非常非常高的水平，因为老实说，这整张幻灯片可能是CS1262中的四堂不同的课，操作系统类，但我只是想回答你可能有的一些问题。
然后就像戳你的大脑一样，这样你就会被鼓励在未来的一个学期选修162这门课，但不管怎样，因此，假设shell想要启动一个新的应用程序或一个新的，呃就像一个，你知道殖民地计划。
也许你知道你打开Vim或类似的东西，嗯，系统调用shell，这个调用恰好被称为Linux中的分叉，它被困在操作系统内核中，虽然，换句话说，操作系统内核部分通常处于监管模式。
那么处于主管模式的操作系统当前占用了CPU，它会加载程序，有关更多详细信息，请查看呼叫讲座，然后跳转到，可能好吧，换句话说，设置PC，PC寄存器将成为缅因州新进程的第一条指令。
然后它将在下一个时钟周期返回到用户模式，然后新的过程就会开始，在这一切结束的时候，一旦进程或程序运行完成，壳牌有点像等待缅因州加入，所以有像另一个或像返回，所以有某种连接的东西。
这可能也需要一些回到主管模式，允许主管模式像，哦耶，这个程序已经完成了，让我们回到节目中，很多信息，这里的重点是什么，陷阱处理员很漂亮，这只是它如何工作的三个例子，页面错误和上下文对这个类更重要一点。
我只想解决一个叫做One的系统，因为我知道一切都会好起来的，哦是的，靴子，我们不会得到它，但是啊，但又一次，这里有一个五分钟的视频，你可以点击，非常棒，它在一个博罗旁边。
一直在教这门课，我确实建议你有效地检查它，它只是想告诉你，呃。
操作系统如何真正启动，有一种像BIOS的东西，这是第一件运行良好的事情，这个固件会再次喜欢。
呃，查看视频了解更多信息，它将操作系统内核从磁盘加载到内存中。
运行它或跳到它像，然后种子种子执行到操作系统，操作系统开始运行所有的服务，司机们，然后像启动一个应用程序，只是等待输入，又是这样，查看视频了解更多信息，好啦，这就是操作系统。
我们之所以如此详细地谈论接受是因为你还记得。
我们在哪里，我们正在考虑虚拟内存，是啊，是啊，我们正在努力思考如何，我们可以把虚拟内存带回我们在，班级，琥珀我就像上次一样，我想忘了现金。
现在我们要再次记住缓存，但要做到这一点，我们要做一些回顾，这是评论，缓存和主内存有什么区别，主要记忆是像DRAM之类的，它们使用不同的记忆单位，就像它也是不同的术语，所以缓存使用通常大约64字节的块。
然后内存使用页面，通常大约是4千字节，然后任何类型的数据，从缓存块或缓存页抓取的都是偏移量，关于那个单位，因此请注意，缓存块比主内存页和一般内存页小得多。
下面是这种看起来的缓存，呃，我们有有效的比特，你知道肮脏的地方，所有这些东西，也许它有一个或像，如果这里有个标签，如果我们在做某种直接的地图，或者如果我们在做一个完全关联的缓存，然后这里有一个数据。
好啦，所以实际上有数据被存储到这个缓存中。
另一方面，我们有主内存，当我们也有磁盘的时候，它们都使用这种称为页面的范例，它要大得多，然后也许有像，这里有很多页，所以有一些页面是DRAM的，然后有一些页面在磁盘中。
但是下面是关于每个缓存中的每个缓存中有什么信息的说明。
所以记住内存层次结构，金字塔的整个概念是下面的一切都像在更低的层次上。
我在更高的层次上看待一切，是低级别的所有东西的副本，或者说喜欢，让我说，随着时间的推移，我喜欢有点抓狂，所以一切，处于较高水平的一切都是处于较低水平的事物的子集，好吧，那么这个游戏的结局是怎样的呢？
每一关都是快速访问，较低级别的数据副本，较小的一套，但是超快的访问。
假设我们有一个小笑脸和一个缓存，这是一个小缓存，但这个块可能就在我们的L2缓存中的某个地方。
假设块的大小相同，呃，在这些级别中的每一个，这个方块，如果我们想想金字塔，缓存下面是什么，下面的缓存DRAM，所以这个块在DRAM中的某个数据页中的某个地方。
然后这个页面实际上这个DRAM页面也在磁盘的某个地方。
好啦，所以有效地DRAM或原始数据，主内存数据页类似于磁盘页的缓存，因为这就是内存层次结构的样子，这就是三角形的样子。
好啦，让我们将其与页表进行对比，好啦，因为这就像我们学到的新的其他结构，而不是CAS，几周前我们得知，现在我们很好地学习了页表，页表的功能与缓存转换不同。
地址，好啦，所以说，例如，我们这里有页表。
我们这样说吧，你知道的，这里有一个单级页表。
有一个查找，上面写着好吧，不管这个虚拟的，呃，就像这里的这个索引，这是某个虚拟页码的索引。
实际上是内存中的物理页码。
然后下面这一排，也许这是其他虚拟页码。
这将转换为磁盘中某个位置的物理页码。
所以它们不是缓存，页表不是缓存，因为它们存储物理页码和其他元数据，它们本身不存储数据，实际上，让我再说一次，他们存储物理页码和状态位，它们本身并不存储实际数据。
项目现在关心的，页表用于什么。
它们对于查找内存和磁盘之间的内容很有用，这就是我们所说的需求分页，我以前说过这句话，但我只在这里强调一下，因为再一次，在过去的几节课里，介绍了这么多术语，我真的想强调这个术语，正是因为我们将要使用它。
在接下来的演讲中，这里的需求分页是这样的想法，至少根据程序，也许它有一种像，2到32字节的可寻址内存，但实际上在后端，有一些重要的页面当前正在内存中使用，然后程序的其余部分都在磁盘上，直到需要加载。
直到流程或程序需要它，页表跟踪所有这些位置中的所有这些状态，然后按需更新。
所以让我们来比较一下这两件事。
缓存与需求分页，它们实际上也在做类似的事情，它将数据从较低的级别复制到较高的级别，以便更快地访问，好啦，但是缓存是在缓存之间，就像某个级别的缓存，假设主内存，也可能是缓存的较低级别。
然后需求分页是在主内存（通常是DRAM）和次内存（通常是磁盘）之间，所以让我们在这里比较一些术语，我们之前说过的内存单元块与页大小的关系，小得多，像64字节这样的块，然后页面就大得多了，就像，呃。
对于TB字节，小姐的名字也略有不同，所以在缓存中，我们称之为缓存未命中，如果必须从需求分页上的主内存加载它，所以在需求寻呼方面，我们称之为页面错误。
好啦，所以请注意这里的术语差异，然后你想起，缓存的全部思想是，比如整理存储空间的方法，当在一级缓存中缓存时，如二级缓存，我们可以有不同的选择，就像直接映射n路集关联，全联想，通常使用需求分页。
我们将使用完全联想，所以这意味着复制的主内存页，从磁盘加载的文件可以放置在主内存的任何位置，他们又不是，它们以任何方式被索引，它们可以被复制和粘贴，那么这里的替代政策是什么呢？用于缓存的井。
您经常使用最近使用最少的或随机需求分页，实际上也经常使用最常用的分页，最近使用最少，但这可能有点像排队，有点像第一个和第一个出来，或者是随机的，最后写政策决定，而缓存通常有右通或右回的选择。
仅需求分页马上回来，好啦，所以右后卫意味着什么，又是那个吗，我们有点喜欢，我们不想访问磁盘那么多，所以每次我们剪辑的时候，我们只是把它做成DRAM，直到这一页从磁盘中冲洗出来。
我说从DRAM中冲出到磁盘上，我们复制所有的信息，所有这些编辑回到磁盘页，好啦，所以再一次，这就像这是一个很好的幻灯片，只是为了让术语明确地开始幻灯片。
如果你是，如果你喜欢在这里记笔记，好啦，所以这是第一步，所以第一步就像我们一样，记住什么是缓存并试图，呃，在我们的头脑中把这些术语分开，你可能想知道，丽莎，为什么缓存有两种不同的术语。
虚拟内存证明虚拟内存是首先设计的，这两个大致是独立设计的，所以虚拟内存有一套术语，然后缓存就像，好啦，我现在要换一套，那里可能有更多的历史，呃，阅读维基百科，如果你想多查点，但是，让我们多谈谈如何。
我们将缓存合并回系统中，也使用虚拟内存。
它是通过一个叫做TLB或翻译的东西，往旁边看，缓冲区，所以让我们至少回顾一下，虚拟内存的一些目标，其中一个目标是，实际上这里有两个目标和一个机制，一种机制是地址转换，虚拟地址到物理地址。
它为什么要做这个翻译，嗯，一个是它想提供一个巨大空间的幻觉，做三个两个字节可寻址的事情，但第二，它想保密，好啦，它希望能够创造，给每个进程一个私有的工作空间，最后它想要统一的存储，或者这想要这种幻觉。
记忆是所有的，是这个巨大的酷，即使技术上有缓存和DRAM，还有磁盘和所有这些类型的东西，那么私处是什么意思呢，私密的部分是这个词叫做保护，这就是虚拟内存为我们提供的几个用户进程。
他们每个人都有自己的私人用户空间，它们都是由操作系统管理的，所有这些不同的页表。
第二件事，统一是什么意思统一意味着需求分页，好啦，所以有效地运行更大的程序，也许比DRAM，大多数东西可能都存储在磁盘上，然后它只是根据需要交换东西。
它还隐藏了机器配置的差异，假设你有小得多的DRAM，但是同样的程序虚拟内存仍然可以运行，或者虚拟内存和地址转换的想法仍然可以运行那个程序，即使你的主内存非常小，那么价格是多少？如果建立保护机制，呃。
支持保护，需求分页是此地址转换，它是虚拟内存的核心，我们需要在每次程序或进程运行或引用内存时执行此操作，我们得把那个内存地址，把虚拟内存地址转换成物理内存地址，所以如果我们在内存中有页表。
这将大大提高性能，或者喜欢它喜欢，都是一样的，我说，这是一个显著下降的性能，换句话说，会增加时间，访问内存的平均时间，所以让我们稍微谈谈这个，为什么会这么慢。
让我们想想我们要用虚拟内存做什么，一个好的虚拟内存结构设计应该是超快的，所以也许翻译只需要一个时钟周期，它还应该是空间高效的，我们不应该像，也许我们想要多级页表。
所有这些都是因为我们不应该占用我们所有的活动，我们带有状态位的主内存，我们可能知道的其他事情，每一条指令和数据访问都需要翻译地址，所以如果你得到一个指令，或者如果你喜欢有一台电脑，你想喜欢。
在该PC寄存器地址加载指令，嗯，该指令针对，虚拟是虚拟地址，所以你需要把它转换成一个物理地址，然后类似地，每次执行加载字或加载字节时，都要进行数据访问，所有这些也都是虚拟地址，它们都需要翻译成物理地址。
所以这就是我们在正确的图表上要去的地方，这里，你还记得吗虚拟内存的整个概念是存储页码，然后你有偏移量，虚拟页码与PPN，然后偏移量就像页面中的字节偏移量。
同样大小的，如果页表在内存中，然后我们执行所谓的每次访问页表遍历，好啦，那么我所说的页表走动是什么意思，我们只是查了所有的页表，直到我们找到我们要找的物理页码，与数据相对应，然后我们做另一个内存访问。
实际上从那个特定的物理地址读取数据，这对单级页表意味着什么，这意味着每个指令提取有两个内存访问，比方说，因为其中一个是像这样查找东西，在页表中查找物理，呃，物理页码，第二个是查找数据本身的物理地址。
然后如果你有一个两级页表，现在你有三个内存访问，第二级查找第一级和第二级页表，然后另一个从物理地址本身查找数据，是啊，是啊，这不是伟大的意义上的喜欢记住，记忆超远，有点像萨克拉门托，非常长的距离。
那么解决办法是什么呢，也许我们总是需要某种记忆，或者实际上，所以让我们用单级页表这样想，其中一种内存访问是访问页表，其中之一是访问数据，现在我们知道如何加快数据访问，我们把数据扔进缓存。
如何加快页表翻译，我们也把它扔进缓存里，哇塞，心灵震撼，这就是所谓的翻译，往旁边看，缓冲器或TLB，这是翻译的特殊缓存，事实上，这是下一张幻灯片的标题。
所以tlb转换本地缓冲区是地址转换的缓存，所以这就像是，离CPU也很近。
它实际上是另一个缓存，但它是一个特殊的缓存，专门用于这种类型的数据。
那么它是什么缓存，它捕获页页表项本身，例如。
呃，它有页面物理页码，你想去找的地方，它具有与页表项关联的所有状态位。
但现在它也有一个标签。
你就像，哎呦，哎呦，我的天啊标签，我知道我记得丹提奥叔叔，是啊，是啊，这是同一种纹身，同样的概念，这里的虚拟页码转换为tlb标记，好啦，然后呃，使用某种索引，我们将在下一张幻灯片中更多地讨论它。
然后将所有这些转换为物理页码。
无需进入内存访问页表，因为这个TLB在某个地方就像缓存一样，它要查找的最近的页表条目集，那么这意味着什么呢，如果我们有一个缓存命中，或者在这种情况下所有的结核病都击中了，那么翻译是一个单一的循环。
因为你只需要，你去缓存，你得到的东西，然后你就完蛋了，你有正确的页码，然后你只要翻译那个物理地址，就像你错过了一个小球一样，现在呢，你得走页表，您必须转到内存中的页表，抢占入口，把它放回去。
现在就像现在就像一个最近使用的条目。
我们把它放进tlp里，再转换成这里的物理地址。
但它很好，至少像现在这样，我们有不一定需要记忆的翻译版本，只要该条目在TLB中。
所以让我们把注意力集中在这个TLB上。
所以记住缓存，所有这些东西都有不同的策略，TLB试图最大化的一件事是，这里是TL B到达，好的，好的，所以我所说的TLB到达是指虚拟地址空间的大小，这是可访问的条目是在内部的反式，过渡看看缓冲区里。
我们想最大化这一点，它实际上有点像，这里发生了很多不同的页面，所以是的，就像它实际上就像，我们想要从缓存本身查找最多的页面数，这里的设计，它很小，三八对一二八参赛，但是因为它很小，然后它想完全关联。
这样就不会有相同索引的条目，有点相互矛盾，您可以将页表项放在表中的任何位置，然后有一个随机的，FIFO或替代政策，那个细节具体的细节留给你阅读，有几个问题，下面是一个在缓存等硬件中实现的tlb。
TB如何区分不同的页表，我们会写信问这些奇妙的问题吗，这将在接下来的几张幻灯片中介绍。
第一件事，虽然，我想区分tlb标签索引和偏移量吗，以及缓存标记索引和偏移量，因为他们在做完全不同的事情，tlb由虚拟页码索引，好啦，那么我这么说是什么意思，我是说你有一些虚拟页码。
你把它转换成一个标签和一个索引。
然后使用TB索引或标记，就像你在缓存中一样，好啦，所以这就是你如何加载它，你存储标签信息，然后你就可以走了，现在你可能想知道，嗯，这件事不是完全联系在一起的吗，所以不是整个TLB的事情是类型，是啊。
是啊，我知道这张图表就像，你知道吗，有点古怪，但你可以想象它被完全索引，TLB领带会占据整个虚拟页码，不管怎样，这正是你现在放进TLB的东西，虽然，呃。
它需要的TLB就像一旦你有了正确的页表条目和TLB，你得到了物理页码，然后你把它敲进物理地址，然后你只需复制页面偏移量，是虚拟地址中的原始内容，那不是虚拟页码，另一方面，数据缓存正在转换。
或者当他们使用标签、索引和相对于物理地址的偏移量时，好啦，所以物理地址实际上有两个视图，其中一个是佩奇，用于TLB的物理页码和索引，然后其中一个是标签，索引和偏移量，用于数据缓存，它使用块。
那么我在这里是什么意思，现在您可能有一些标记索引偏移量，这些是现金，然后索引为您找到正确的缓存项，右边那一排，然后现在偏移量是相对于块数据本身的，所以这些就是这里的区别，非常不同的是。
这是一个非常不同的想法，但使用过程相似，但是你实际上要做的事情是创建标签，指数和偏移量略有不同。
好啦，所以现在我们开始回答这里的几个问题，TP也是在像缓存这样的硬件中实现的，现在我们的问题是，如何落实，我们有一个数据路径，请记住，我们按照什么顺序做这些事情，所以这里有几个问题要问你。
缓存能保存请求的数据吗，如果相应的页不在主存中，其次，我们应该先转换虚拟地址，然后访问缓存，或者我们应该访问缓存然后翻译所有的地址，迷人的问题，所以我给你们三十秒来处理这些想法，就像，你知道的。
再检查一下，仔细检查您对缓存的理解，Tlb，DRAM页表，所有这些事情，你这样有什么意义，这张图是什么，我的意思是，丽莎，下面是什么，假设cpu当前正在执行这个指令加载字节，还有这个指令，呃。
有一个内存地址请求，十六进制f f f f零零四，也许嗯然后我们希望能够得到那个字节，在这个虚拟地址，那么事物的访问顺序是什么呢，所以如果我们喜欢，通过这个由不同块组成的巨大云提供一个虚拟地址。
我们希望能够获得并请求数据，但那片云实际上是什么样子的，关于我们现在正在处理的所有这些不同的块。
好啦，所以让我们考虑一下，缓存能保存请求的数据吗，如果相应的页不在主存中，我们在缓存审查中看到了这一点，所以再一次，就像缓存，缓存中的所有东西都在主存中，主存里的所有东西都在磁盘里，好啦。
所以答案是数据也必须在主存中，现在第二个稍微参考一下图表，我们应该如何访问这些信息，实际上有几种不同的实现，但我们将在CS中讨论的一个，61 C是所谓的物理索引，物理标记，现在你不需要特别记住这句话。
但你需要记住的是61C是怎么想的，是先有TLB然后是缓存。
这是什么意思，这意味着我们首先进行翻译，然后进行缓存，这些标签都是物理地址，物理指数，物理标签，所以如果我们没有一秒钟的记忆，然后是典型的翻译过程，如果一切都很成功，然后TLB就会像，哦耶。
我有正确的页表条目，现在我要转换物理地址缓存，去吧，缓存就像我有这个块，我会回来的。
或者我会满足那个请求，数据返回到CPU，现在如果tlb没有页表条目怎么办，有雾，它必须在页表上行走，好啦，所以它去或喜欢它，就像这里的处理器可能要进行页表遍历，因此发生页表锁定。
然后它得到正确的页表条目，现在这被更新或写入TLB，好啦，所以这有点像，这就是这，每当您执行页表遍历时，都会发生这种情况，有点呃，它是由，呃，操作系统和CPU本身，其实呢。
我会在TLB直播中回答这个问题，我们个人不写信给结核病，它是以同样的方式处理的事情，缓存也在更新中处理，从硬件上看，最后，如果块不在缓存本身中，会发生什么，好吧，那就不是缓存小姐，好啦。
所以如果结核病或无论如何，所以作为一个缓存神话，然后我们需要进入主内存，然后抓住右边的方块，把它放到缓存里，然后缓存将请求数据的特定字节返回到当前执行的指令，CPU内部，那么这里的重点是什么呢。
有什么好主意，让我看看，街区在哪里，我们没有街区，也可能我们有，呃，开始了，呃，这里的要点是，TLB现在是做翻译的人，不是页表，换句话说，最近访问的所有页表项都在TB中，就像变性人。
就像翻译逻辑发生在TLB内部，与缓存返回数据的方式相同，不是不记得对吧，内存将东西加载到缓存中，缓存将东西返回到CPU，页表为TB提供页表条目，然后在tlb中使用页表条目进行翻译，所以只要一张纸条好的。
现在我们准备好回答最后一个匿名与会者的问题，我们拿不到最后一节了，嗯，所以我就把它留到下一次，但是数据路径中的Tbis。
为什么这里指的是不同的页表，我们马上就能看到，我们从上一节中看到了什么，上一节说地址转换是虚拟内存的核心实现，它提供保护和需求分页，那么这意味着什么呢这意味着每次我们进行地址转换或地址转换时。
我们应该努力提供保护和需求寻呼，所以如果我们有这里的数据路径，我们的管道数据路径，然后让我们来看看地址转换确实会发生的两个地方，其中之一是当我们访问指令时，当我们加载指令时，如果我们要访问这个指令缓存。
我在，我们需要在那之前有一个结核病，至少在这门课上，好啦，因为我们先翻译，然后同样地，当我们试图访问数据存储器时，DM缓存，所以是的，不是数据存储器，数据缓存，在那之前我们还需要做一个地址转换。
这里会有另一个TLB，好啦，所以相似的两个不同的TLB，就像我们有两个不同的缓存一样，一个用来指导，一个是数据，那么这意味着什么呢这意味着这些小球中的每一个，当它翻译的时候，它需要提供所有这些保护。
所有这些需求寻呼。
所有这些异常处理，所有这些类型的事情，所以它应该处理以下TLB小姐，好的，好的，我们为什么要叫TLB，这里的小姐，TLB是缓存，因此，当你喜欢的时候，没有一个条目被称为小姐，不知何故。
您需要重新填充此TLB或更新此TLB，这通常是在硬件中完成的，只是重复一些问题从只是重复答案，对于之前聊天中的一些问题，它需要做的第二件事是，也许它应该处理页面错误，为什么我们要用过错这个词。
现在我们要处理的是需求寻呼系统，所以如果页面在磁盘上，它需要喜欢它，就像这里的整个系统需要一个精确的陷阱，好啦，然后任务可以，或者就像这里的赛道管理员会喜欢这样，好像它会处理异常，它会得到那些信息。
然后它会重新执行指令，最后它需要做专门的保护检查，此过程通过，比如试图访问它没有的内存，否则它可能违反了保护规定，然后软件也应该陷阱然后，哦，我明白了是的，然后也应该捕获，然后触发分段故障或类似的东西。
好啦，所以这个违反可能这个过程意味着，那个过程不能继续工作，它需要被终止，所以考虑到这一点，这是一个非常高的水平，也有一些硬件软件的分裂，所以你可以理解发生了什么，每次你翻译一个地址。
你做的第一件事就是在TLB上查一下，如果你，或者错过那些，只有这两个选择，这是TLB的，然后你做两件事中的一件，如果你击中了如果你击中了，然后你做一个保护检查，如果你一开始就能写或读这段记忆。
也许你检查了那个状态位或不，如果它被拒绝，那就是保护故障，然后你触发了一个异常，然后呃，陷阱处理程序应该在另一方面的某个地方造成错误，如果允许的话，然后你确实得到了物理地址，就像翻译工作一样。
然后现在你去缓存获取数据，所以再一次，这就像翻译部分本身一样，如果TLB没打中怎么办，然后进行页表遍历。
好啦，所以您遍历这个多级页表，也许你找到了物理页码，那么你擅长什么呢？您可以检查此页是否在内存中，或者此页是否再次不在内存中，也许是地位本身，它在记忆中，你更新了TLB，通常超快。
然后你回到流程图的开头来做翻译，理想情况下，你可以在那之后去缓存，如果页不在内存中，这就是所谓的页面错误，然后加载页面，也许做一个上下文切换，因为进入磁盘和所有这些东西需要很长时间。
然后回到流程图的开头，所以这就是翻译和保护流程图的想法。
所以大家可以看到，有很多不同的步骤，如果你有兴趣，有这样的，有一张古怪的桌子，好啦，这里其实还有三十秒，所以有一张古怪的桌子，呃，那将会，我会在下一张幻灯片里，录音里也有，但是上下文的想法在这里切换。
只有一个部分允许上下文切换发生，这是指。
呃，我们在问答中的最后一个问题，就像，还记得我们说过的页表寄存器，它也被缓存了，或者那也被保存了，每当我们做上下文切换时，事实证明，TL B，我们可以考虑T B条目的一种方法，就是。
也许T B项应该只与活动过程本身有关，因此，陷阱处理程序可以将所有的tlb条目设置为无效，然后就像新的加载过程，然后你有这个TLB小姐，因为它想繁殖，呃，到正确的页表，这只是一个选择，事实证明。
在当今大多数先进的处理器中，它只有多个页表，也许它的索引很少，但这是我们今天上课要用的，好啦，我们又没时间了，如果你对数据路径超级感兴趣，这一部分就会被记录下来，你想去看看吗，一定要去看看，呃。
但是有了那个，我们将在周二发布更多公告，大概啊，这一切将如何运作，鉴于罢工仍在进行，这意味着罢工没有结束日期，有了那个呃，非常爱你，所有的爱给我们所有的人，我们美妙的，地理规模和新规模，星期三见。
谢谢再见。
P46：Lecture 35： VM Performance, I／O - 这样好__ - BV1s7421T7XR
大家好，欢迎回到我们的操作系统和虚拟内存模块。
但是现在我们很清楚虚拟内存系统是如何工作的，甚至我们甚至知道如何实现它，所以剩下的就是评估它的性能，我们甚至知道，因为我们将使用一套相同的原则，我们已经使用了。
评估缓存的性能。
所以开始吧，让我们比较一下高速缓存和虚拟内存系统。
所以不管缓存版本是什么，不管我们叫它块还是线。
对应于虚拟内存系统中的一个页面，嗯，缓存未命中对应于页面错误，缓存中的块大小为3，2到64字节，我们正在处理的典型页面大小是KB，有时页面大小会小一点，到基比可以更大。
八到十六个奇比人，但我们通常处理四页。
在缓存中的放置可以是直接的。
映射或以任何方式设置关联，一般在。
虚拟内存系统，我们的页面是完全关联的。
缓存中的替换策略可以是最近最少使用的，也可以是随机的，或者介于两者之间的任何东西。
嗯。
在虚拟内存系统中，我们通常希望用最近使用最少的。
但有时我们会用一些东西来近似，这些东西最终可能是。
要么是先进先出，要么是随机的，右后卫政策。
回写到RAM。
万一，嗯，一个缓存，我们可以，我们可以选择在虚拟内存系统中直接和直接返回。
我们只回信。
因为回信的惩罚。
写入磁盘是如此之高，所以我们准备好评估性能了。
虚拟内存系统中的性能将以同样的方式评估。
如何评估缓存系统的性能。
虚拟内存是低于主存的内存级别。
在我们之前的计算中。
一切都停在主存的昏暗级别，现在呢。
虚拟内存通过在true中分页将DRAM扩展到缓存中。
我们的虚拟内存通过分页将该定理扩展到磁盘中。
所以尽管结核病出现在缓存之前，它影响数据。
你知道的，从磁盘到主存的数据传输。
所以在我们之前的计算中，主存是最低的。
我们只需要，说明我们的数据实际上不在DRAM中的情况。
但我们得找到一个磁盘才能取回它。
因此，每条指令的周期和平均内存访问的时间将被应用于，但这次，我们将把我们的主存看作是某种中级缓存，所以我们要检查一个缓存，命中未命中，当时的猜测，或计算，然后呢，两次命中和未命中。
然后我们会撞上公羊或错过，最终进入磁盘，以下是我们关心的一些参数。
所以当我们计算，你知道的，在我们的计算中，我们有CPU缓存和主内存。
现在我们将有CPU主内存和一个次内存。
所以当我们谈论缓存时，我们讨论了需求分页中的缓存条目。
我们正在处理页面框架。
三个2到64字节的缓存块，就像我们说的，在页面为QB之前。
当我们谈论缓存脱靶率时。
当我们得到个位数的东西时，我们通常很高兴。
所以通常情况下，你知道的，Lone缓存就像百分之一。
呃，点击率，百分之二十，也许十个，二，百分之二十。
现在失页率必须低得多。
通常嗯，万分之一还是十万分之一。
或更低。
你知道我们的缓存设计得很好。
在大多数情况下，基本上我们在一个周期内从缓存中获取数据。
缓存未命中对应于RAM中的页面。
所以这将是从十个几个，现在几十个循环到一百个循环。
页面丢失对应于五百万个时钟周期。
因为这是要多少我们去磁盘。
与吉姆格雷去冥王星的比喻相对应。
所以让我们来看看分页的影响是什么。
平均来说，内存访问是时间，嗯，因此，让我们假设我们有以下相当常见的内存参数。
我们可以插入任何你喜欢的数字。
在我们的考试中可以做到这一点。
所以说，嗯，让我们看看Lone缓存它是在一个时钟周期内完成的。
我们用95%的访问来做到这一点。
两个缓存需要十个时钟周期，命中率是六成。
假设100纳秒。
这对监控系统来说有点悲观，通常会更少，但这对当前的计算来说是可以的。
最后这个案子有两千万个时钟周期，比如说十毫秒。
我会更快，如果我们插入固态硬盘，所以不分页的平均内存访问时间。
嗯，这一次的计算是，如果我们没有错过。
如果我们找到了，我们可以在一个时钟周期内完成所有事情。
一个时钟周期内的缓存，然后我们需要加上错过的惩罚。
所以我们有5%的概率会失手。
一个，这将花费我们十个时钟周期。
然后我们错过了，嗯，在L 2。
一次有百分之五的失误，在L两次中，一个失踪的40%。
两百个循环，把我们带到公羊那里，所以计算为5。5个时钟周期。
好啦，这有点悲观，你知道的，现代系统会比这快一点。
但让我们看看，我们如何修改它以考虑分页内存系统。
所以要添加分页，我们需要做的是，我们需要拿这个五点五，针对并添加分页的影响，所以让我们这样做。
所以分页的平均内存访问时间相当于我们的5。5个周期。
加百分之五乘百分之四十五。
可能他们会错过，40%的小姐。
二乘一，减去我们的数据不在DRAM中的内存命中率。
它要走了，我们得找到一个磁盘。
这将花费我们两千万次循环，谨记。
两千万与任何其他数字相比都是一个巨大的数字，所以进入内存的命中率最好非常接近。
所以我们提到它必须比99%更好，但让我们来看看会发生什么。
如果只有百分之九十九，所以我们把它插入5。5加0点。
两次零点零一，也就是二千万的负九成九。
我们有四千张地图，那是慢了七百倍的机器，太可怕了，那是一场可怕的表演。
顺便说一句，这在实践中确实发生过。
如果，如果我们的物理内存快用完了，流程太多，课程太多。
也许共用一台机器，嗯，机器每一百个循环不断地交换。
或者将去与磁盘交换页面。
这就是所谓的痛击。
通常当机器在敲打时，它就像慢了一百倍到一千倍。
所以让我们看看如果你有更好的命中率会发生什么。
所以是的。
这就是我们所看到的，当一个程序。
你知道的，如果太多人共用一台机器，一个十秒钟的节目可能需要两个小时。
命中率是九十九点。
百分之九好，事情变得更好一点，但也好不到哪里去。
它仍然是四百块--比我们以前的差了很多，最后让我们看看如果这是一个更合理的数字会怎么样，如果我们的命中率或者误打误撞是万分之一，五点五到五点九，哪个更合理，这是我们经常遇到的事情。
这基本上就是我们需要做的，我们可以休息一下，然后我们将看到如何将IO设备集成到其中，一会儿见。
大家好，欢迎回到我们处理虚拟内存和操作系统支持的模块，但现在我们已经基本弄清楚了虚拟内存是如何工作的，所以我们想做的是，为了完成我们的计算机系统是添加IO设备。
所以让我们开始吧，到目前为止，我们在这门课上取得了巨大的进步，我们几乎造了一台计算机。
所以我们从一个高水平的C程序开始，通过第一个项目。
然后我们学习这五个的汇编语言。
我说并实践，并通过项目二真正巩固了它。
然后我们建立了一个数据路径，几乎可以执行我们的程序，从项目到减去等于。
但那并不难，虽然不是去教育那边实施。
他们只是增加了一个负担。
所以我们可以假设我们可以建造，我们几乎可以运行我们建立的所有项目2，我们也可以编译我们的项目一，并在我们的核心上运行它。
我们添加了高速缓存，然后我们连接虚拟内存。
因此，为了拥有一台计算机，我们所需要的就是添加IO设备。
这样我们就可以连接键盘和鼠标，并在屏幕上显示我们的结果。
或许呃，连接到网络。
这里的关键是我们想理解原则。
这些我是怎么，O，设备连接，这样我们就不必用一些特殊的程序一次做一个。
所以让我们开始吧。
那么我们如何与设备交互，所以我们有一个在CPU上运行的程序，然后它想在打印机上打印一些东西，或者从击键接收um输入，那么我们该怎么做呢。
所以我们有处理器和内存，有一些代码在上面运行，所以我们需要有一个I，O，键盘接口，网络鼠标。
显示器等，你想以统一的方式做到这一点。
这样我们就不必为他们每个人单独做了，通常会有太多的设备。
他们会有非常不同的要求。
或者他们呈现数据的方式，或者他们如何获取数据。
但你想试着以统一的方式对待他们，它们通常通过一些公共汽车的层次结构连接起来。
我们观看这些公共汽车的方式就像。
你知道的，公路，嗯，大量数据以相对较高的速度移动，然后是与高速公路相连的坡道。
我们只打算深入探讨设计公共汽车的细节。
嗯，我们可以把它们看作是连接到处理器存储系统的抽象的东西。
这些设备与世界其他地方的通信方式通常是通过标准化接口，它由命令和状态寄存器以及数据寄存器组成，一般来说，是检查状态的操作系统，其他设备准备好和我们对话，然后编排下面的进程如何访问这些设备。
所以标准化的接口他们通常有命令，我们说点什么吧，然后数据寄存器包含实际要打印的内容，我们如何支持这种I。
O，通过我们的ISA进行接口。
嗯，所以它在最底层是相对基本的。
以及处理器需要做什么的叶级别，它需要能够读取一系列字节。
写一个字节序列，不管是命令还是数据。
那么我们怎样才能做好呢，我们有两个选择，一种设计，特殊输入输出指令，匹配的硬件将与每种类型的设备对话，过去是这样做的，曾经有我，O，处理器中的指令，但事实证明这不是个好主意，因为这些设备会改变。
我们有了新的标准，每隔几年就有新的接口，旧的变老了，抛弃了过时的，我们的ISIS被支持的东西困住了，那可能是十岁、二十岁或四十岁，所以现在的大多数事情实际上都是，通过所谓的内存映射，I，哦嗯。
一般地址空间的部分，所以我们内存空间中的一些低地址，在我们的记忆中，位置是献给我的，我们的io命令和数据寄存器就放在那里，所以我们不使用记忆的那一部分，它对我们的程序是不可见的，它由操作系统管理。
我们的进程可以从那里读或写，嗯，所以如果他们被允许，它们可以使用正常的加载和存储指令来访问它们，或者可以通过系统调用访问它们，风险五是这样做的。
所以这里有一个例子，本例中有一些地址。
七个以下的所有地址。
我们的记忆，内存映射的保留，I，我们所有的外围设备都会在那里复制。
它们的控制状态寄存器，他们会给他们读和写。
那将是我们的交流方式，所以我们的程序和数据存储器将从地址8 0 0 0开始。
零零零，并上升到内存的顶部。
所以每个IO设备都有一个寄存器的副本。
在映射的内存中。
伊诺，有一件事要记住。
外面有各种各样的设备，它们可能以非常不同的速度运行。
所以如果我们的微处理器只是一个坐标，五处理器说五级管道在一个运行，它可以为每秒GIB的负载和存储，它可以在每个循环中写入，假设AAT在附近的某个地方，嗯一个。
它可以在每个循环中进行一次四字节加载或四字节存储，但是有一大堆设备可能无法使用它，或者一般不会使用它们，除非他们是公羊，所以让我们来看看外面有什么，所以如果你用键盘工作，真的吗，我们对着键盘说话的速度。
相当于每秒的字节，嗯对，我是说，这就是速度，我们可以键入的最大速度，嗯，你知道的，人类和人类的手指可以以每秒最大的速度产生几十字节。
如果是我，它是，你知道的，也许每秒几个字节，然后如果你在处理音频信号，通常与，你知道的，蓝牙现在通常被用来传输音频信号，每秒只有几百个基比，每秒可以达到3兆字节。
然后当我们谈论WiFi和以太网时，你也知道，最难的驱动器，我们可以达到更高的速度，但没有一个能接近，它们通常至少在数量级上，低于处理器的速度，直到我们像霹雳一样，然后嗯，现在呢，那些一般是。
那些超出核心读写带宽的，专为支持高端处理器而设计。
而那些有多个核心的，因为这些核心中的每一个都可能希望将数据加载或存储到内存中。
通常常见的IO设备既不传递也不接受数据，匹配处理器速度，我们得有办法适应，我们将看看几个可能的选择，怎么做，稍作休息后，到时见。
大家好，欢迎回到我们关于输入输出设备的讨论，我们已经看到我们经常处理各种各样的设备，它们通常使用非常不同的数据速率，他们中的一些人很慢，其中一些可以产生大量数据。
处理器需要跟上，我们也看到一般情况下，我们使用这些设备的方式是通过与它的内存映射寄存器对话，它们的内存映射寄存器，所以它们有两种寄存器，或至少，每种类型都有一个控制寄存器和一个数据寄存器。
这些控制寄存器基本上会告诉我们是否可以，向设备读写数据，我们可以用一个旗手在路上的比喻，这告诉我们是否可以通过，穿过部分道路，如果他们有升起的旗帜，这意味着我们通常应该停止，如果他们把旗子掉了。
那就可以走了，同样地，这就是控制寄存器告诉我们设备是否准备好接收数据的方式，如果我们写信给它，或者它已经准备好数据供处理器读取，那么应该从数据寄存器中读取的数据在哪里，这也是我们要写信给的登记簿。
在轮询过程中，处理器反复或定期检查控制寄存器，那里通常有一点是准备好的，就绪位意味着设备准备接收数据，或者它有一些准备发送到处理器的数据，未就绪信号为单位，它是由设备控制的。
设备um通过将其值从0改为1来设置它，然后处理器将从设备加载或写入设备，不管是输入设备还是输出设备，伊娥装置，将控制信号从1重置为零，就像我们说的，这是一个叫做轮询的过程，让我们看一个轮询代码的示例。
顺便说一句，这是最简单的程序，你知道的，我们将使用的最简单的方法，也是我们可以用来处理输入输出设备的方法，在本例中，我们有一个包含一个输入设备和一个输出设备的内存映射。
这些设备中的每一个都是一个控制器和一个数据寄存器，所以输入设备，一个输入控制寄存器和一个数据寄存器，输出设备有一个控制寄存器，一个数据寄存器，所以这里有两个循环，一个用于处理输入设备。
另一个与输出设备相反工作的，进入内存映射的条目被设置为值7 f f零零，最后三位是零，方便地使用路易将该地址加载到临时寄存器中，我们也不必在它后面立即添加，然后我们进入这个循环。
循环实质上从控制寄存器加载值，输入控制寄存器，并检查就绪位是否已断言，它是否等于1将留在这个循环中，只要等于零，这和立即将保持，你知道它将产生一个零的值，除非准备好了，哪个是这个寄存器中最低有效位。
如果是的话，它会退出循环并加载数据，我会做任何需要做的数据，在某个时候继续投票，输出轮询的工作方式与我们希望的完全相同，例如，当我们再次去路易斯的时候，从一个写到显示，我们要进入重量循环。
现在我们要检查适当的寄存器，我们要去，嗯，当设备准备好时写入它。
所以这是非常简单和方便的，但这并不总是处理。
I，O设备，所以让我们假设我们正在处理的标准处理器。
我们一直在处理以十亿赫兹时钟速率运行的。
假设一次轮询操作需要400个时钟周期。
所以我们称之为轮询例程，你知道的，检查设备，不管是键盘还是WiFi。
你知道它是准备好给我们发送数据还是接收数据。
然后回来有多少时间。
处理器需要花费多少百分比的时钟周期用于轮询，让我们看一个简单的例子，通常鼠标需要每秒拉三十次，为了避免屏幕上的抖动，嗯，那么让我们说说我们投票的成本是多少。
拉鼠标查看是否更改了此数据。
如果它改变了位置，当我们拉一只老鼠。
假设我们说每秒需要三十杆，每根杆子需要四百个钟才能完成。
那就是每秒一万两千个时钟。
所以如果处理器在拉鼠标。
那么这只是正在进行的总时钟周期的一小部分。
每秒钟都有。
所以我们把12k除以十亿个时钟周期。
虽然那是零点，零零，百分之一。
嗯，那不是很大的负担，因为处理器和处理器可以拉这种输入设备。
然而，如果我们把所有的设备都拉出来，这有点不实际。
我们不知道什么时候该停止寻找投票鼠标。
如果我们知道有人，如果没有老鼠活动。
现在没事了，嗯，让我们来看看不同的设备，拥有更多数据的设备，例如，嗯，如果你想拉一个磁盘和磁盘，假设是，中快，每秒能产生16兆字节的，我们需要每个极点做16个字节，所以我们需要每秒一百万杆。
你知道我们需要花多少周期，循环的百分比是多少，所以我们需要每秒做一百万杆，我们又要花四百个周期。
做每次民意测验，每秒有4亿个时钟，我们会花在轮询磁盘上的钱，我们每秒只有十亿个循环，这基本上意味着这个处理器将不做其他事情，把40%的时钟周期，基本上会使处理器无法做很多其他事情，顺便说一句。
还要拉出产生大量大块数据的磁盘，拉它们来接收小块的东西真的没有多大意义，因此，试图每极获得16个字节可能不是最好的方法，我们需要想出一个更好的方法来使用这些设备，可以产生大量数据，我们会发现。
当我们发现它很可能会在其他事情上使用更好的机制时，我会说的，稍作休息后，到时见。
大家好，欢迎回到我们关于输入输出设备的讨论，我们引入了轮询作为处理输入设备的一种方法，但它通常效率低下，尤其是那些有大量数据要发送或接收的，这是一种有效的技术，我自己过去也用过。
尤其是在做一些原型的时候，什么时候，例如，吃一个覆盆子皮，想嗯，弄清楚，如果某个新的IO设备工作正常，我们能做的最简单的事，设置一个非常短的轮询循环，看看设备通常做什么。
方式，我们如何使用IO设备是通过一个已知的中断机制。
因此，我们已经强调了轮询浪费处理器资源，为什么好，仅仅是因为输入输出设备是否有东西告诉我们，嗯还是不，不管怎样，我们去看看，它怎么样了，如果它没有数据给我们，我们仍然花费处理器周期，拉一下。
在现实生活中有一个类比，你知道的，当我们开派对的时候，这将轮询相当于设置一个计时器，每时每刻都去前门检查，如果有人来了，我们不这样做，因为很久以前人们发明了门铃来阻止我们这样做，所以当客人来的时候。
他们按门铃宣布自己，类似地，当他们有事情要告诉我们时，一个io设备会按门铃，他们的门铃是打断，所以他们会打断，或者在他们有数据要给我们的时候中断，或者如果有一些，他们想告诉我们一些事情，当前程序。
然后我们将把控制转移到操作系统中的陷阱处理程序。
为什么中断比轮询好。
因为当什么都没发生的时候，否，我没有消息，O，装置，没什么可做的。
如果有，如果设备没有产生大量数据。
也没有很多活动，这很好，因为我们只是周期性地收到这些中断。
并相应地处理它们，但是如果设备有很多。
我看到了，木卫一，嗯，中断是昂贵的，因为它们中断了当前的程序。
丢弃缓存，把TLB扔掉，我们得去拯救国家，拯救国家，恢复状态，然后你知道，预热缓存等，所以他们不是最好的办法。
适用于低速率器件，他们更喜欢投票，所以我的键盘等会使用中断。
在产生大量数据的设备中。
一种更常见的方法是，它们将用中断启动数据传输。
当他们有东西给我们的时候。
通过WiFi接收数据包，但转移通常是。
如果有很多数据要传输，它是通过使用不同的机制来完成的。
嗯，所谓的直接内存访问是或dma。
在我们进入下一节之前，我们将在下一节中讨论，有一种更古老的方式，基本上是精心策划的轮询，也就是所谓的IO程序，P o这是用旧的ATA风格的硬盘引入的，可能没有ATA明星，一种硬盘，本质上。
这是一个处理器的角色，以启动所有的数据时刻，从硬盘上，它是以一种比仅仅使用负载和存储更有效的方式完成的，但是货物和商店开始了，嗯，所以CPU通常会花费一些周期，呃，从磁盘和主存中获取数据。
但那是用来做主要计算的同一个CPU，所以处理磁盘是一项开销，通常，进入IO程序的是大约5%的处理器周期，这种事情还是会发生，大处理器中仍有指令正在处理，用于将一段数据从一个位置复制到另一个位置，例如。
如果你看看谷歌的工作量，他们报告说，大约5%的cpu周期使用mem copy之类的指令，从一个内存位置复制到另一个，我们将看到一些其他的方法，就像断开后的DNA轴，只要有可能，我们就会利用它们。
当我们有很多数据要移动时，稍事休息后再见。
大家好，欢迎回到我们关于输入输出的讨论。
到目前为止，我们已经看到了两种处理输入输出设备的机制。
中断。
中断，实际上被用于不产生大量数据的设备。
不要消耗大量数据。
那些消耗大量数据的现在通常是基于直接内存的。
访问是一种不同的机制。
让我们在这里介绍一下。
唯一能够控制数据传输到主存的设备。
是处理器本身，为了卸载处理器。
所以它不会花很多时间处理这些负载和存储。
我们得想出一个新装置，那就是。
新硬件，这将帮助处理器在主存之间移动大块数据。
可能和我们的处理器在同一个芯片上。
但它会。
操作它将在CPU的监督下控制内存通道。
所以本质上，这里将要发生的是DMA引擎将独立工作。
它有一些由CPU编写的寄存器。
你知道嗯，可能是记忆映射。
这些寄存器将包含。
用于放置数据的内存地址，要传输的字节数。
i的数目，O，应该做的设备。
在存储器上或从存储器转移到存储器的方向。
转移的单位和每节应该做多少。
因为它可以做多个。
为了说明这是如何工作的。
这里有一张课本上的图片，我们可以用。
CPU将启动传输。
不管是去记忆还是从记忆中，它将写，地址。
伯爵，和控制位进入DMA控制器。
反过来。
DMA将请求从设备传输到内存。
也许你知道，一般情况下，有大量的数据可以移动的是磁盘。
或者可能控制多个磁盘的磁盘控制器。
所以光盘现代磁盘通常有缓冲区。
它们可以提前读取并缓冲一些数据。
关于它们的不可忽视的数据量，所以dma引擎会告诉它，基本上，您将其缓冲区的内容转移到特定位置。
在CPU指定的内存中。
当它完成与转移。
会卖出去的，此控制器将向dma引擎发送确认。
引擎会中断CPU，告诉它完成了，文件已被移动。
移交已经完成，所以CPU只被中断两次--首先开始传输。
那么转移可能会很长，我们可能会移动兆字节或千兆字节的数据。
这是我通常做的，呃，当来回移动这些视频时，嗯然后你很清楚。
当数据移动时，CPU还可以做别的事情，当它完成的时候。
它又被打断了。
好啦。
让我们，你知道的，穿过那个，呃，对于数据的传入方向。
处理器将接收来自设备的中断。
呃，它需要中断，然后嗯，通过一个陷阱处理程序，它将启动转移，它会指示dma引擎，将数据放置在内存中的某些地址。
设备和DMA引擎将自己处理传输。
CPU可以自由地继续执行一个程序，你从中断的持续中返回，在完成时做它一直在做的任何事情。
该装置，桌子和这个箱子。
和DM引擎再次中断CPU一般，设备中断。
DMA控制器和DMA控制器中断。
告诉你的CPU已经完成了，在数据的传出方向，如果CPU有想要从内存移动到外部设备的东西，嗯，它首先启动传输，它通过读取设备的控制寄存器来确认设备已准备就绪。
然后开始转移，嗯可能更确切地说。
就像我们在这里说的，开始转移，它指示dma引擎。
嗯使用一个设备，告诉它数据在内存中的某个地址可用。
然后DMA将与设备一起工作。
处理传输的磁盘，CPU下一步想做什么就做什么。
设备确认它已经将数据接收到DME，DMA发动机，中断CPU以发出完成信号，就是这样，这听起来相当简单和酷，这些事确实，你知道的，我们提到过我们有程序，作为一种运作方式，在90年代有80张桌子，嗯。
DMA在2000年取代了它，现在大多数的磁盘，或者现在所有的磁盘都支持传输，但是还有一些其他的问题，这些dma控制器与处理器共享芯片区域，我们有自由。
我们想把它们插进去，那么我们要把我们的dma控制器放在内存层次结构中的什么位置呢？
嗯，有两个极端和许多其他变体。
首先，我们可以把它放在CPU和L一个缓存之间，所以我们可以把它插在那里。
如果我们那样做，我们得到了自由的一致性。
意味着处理器，记忆系统，缓存系统将处理一致性。
问题是每次我们启动主传输。
我们要用传输数据来破坏CPU的工作集。
另一种选择是将其放在最后一级缓存和主存之间，所以我们不会弄乱处理器缓存，处理器上的中断可以在处理完中断后立即进行，可以恢复它正在做的事情，我们需要实现一个新的一致性引擎，这通常是正在做的。
无论如何DNA必须，有一个具有一致性引擎的踢腿来支持它，这就是DMA和一般处理IO设备的方法。
下面是一个快速的例子。
然后我们就完成了这个模组，稍事休息后再见。
你好，欢迎回到模块的总结，它一直在处理，操作系统，虚拟内存，而我，O，设备，我们到目前为止谈到的设备，一般处理一台机器内的设备，一台计算机，磁盘，键盘，老鼠，显示器，以此类推。
我们是否做了一些不同的事情来通过网络将我们的计算机连接到我们的计算机上。
嗯，这一切都是按照同样的原则进行的，所以让我们快速回顾一下我们如何使用网络。
所以网络的想法最初是为了在计算机之间共享设备。
就像办公室里的打印机。
开始对在计算机之间移动文件更感兴趣。
而不是仅仅在我们过去拥有的设备上复制它们。
那叫做软盘，嗯，您可以使用FTP或文件传输协议直接将它们发送到另一个设备。
然后他们发现他们不必像。
键入了关于，你知道的，一些文件或，或者演讲之类的。
开始在计算机网络之间进行通信。
所以我们最终建立了世界各地的文件共享网络。
网，很多，很多，运行当今世界的许多其他事情。
互联网是如何开始的。
从很久以前的想法开始，大约1962年，利利德都叫湖，当他在做这些ARPA的时候，现在国防高级研究计划局写了一份备忘录描述了连接计算机的愿望，他的目标实际上是一个研究网络，它将连接斯坦福大学的计算机。
伯克利和加州大学洛杉矶分校在1963年，所谓的Arpanet首次亮相并连接，与加州大学洛杉矶分校斯坦福研究所相比，犹他州和加州大学圣巴巴拉分校而不是伯克利，然后罗伯特卡恩和本赛普发明了tcp。
它现在是互联网协议套件的一部分，这是一种方法，从第一天起，这种连接计算机的愿望很有吸引力，从那时到现在，互联网一直在呈指数级增长，在可预见的未来。
万维网是在我89年上大学的时候出现的。
一开始很笨重，它是由一个术语来实现的。
蒂姆·伯纳斯，李，呃，从，然后我想蒂姆搬到了麻省理工学院。
它被称为互联网上相互联系的超文本文档系统。
嗯它，这个想法源于，呃，在巴纳罗灌木丛的早期，嗯，一个真正伟大的计算先驱，称之为远见，像那样的系统，但没有实施，没过多久整个世界就爆炸了，我们目睹了结果，接下来是2001年的破产，但一切都恢复了。
我们可以进入任何地方，那么协议背后是什么。
嗯，数据包。
这些数据包是由软件产生的。
软件会，你知道的，软件应用程序将把数据复制到缓冲区。
或者计算某种校验和。
如果在传输过程中出现错误，因为当他们走得很远。
你知道远行或长途旅行，有些位可能会被损坏。
启动计时器，然后将数据发送到网络接口。
一种硬件网络接口，他说，开始。
数据以特定的方式打包，正如这里所示，嗯。
它有源的目的地地址。
长度，因为其中一些数据包可能是可变的，长度，有一些确认信息和有效载荷。
可能是评论，地址或数据。
最后有一个作为预告片，在印度以校验和的形式，最后检查他们，现在呢，嗯，在接收端，数据将显示在另一个网络接口中，嗯，你知道的，这是一个特殊的卡，将被转移到操作系统缓冲区，我想你在猜什么。
我们怎么会被转移到缓冲区，否则我们会检查，如果校验和正确，如果匹配，如果可以的话，它将把确认发回给发送者，嗯，如果不行的话，然后它会删除消息，呃，嗯，寄件人会再寄一次，寄件人也会再次发送，如果。
如果计时器过期后没有收到确认，如果一切都好，消息已收到，操作系统会将其复制到用户空间，并发出请求继续的信号，我想我们都知道，怎么做，为了实现这一切美好的事情，我们需要什么。
嗯，我们什么都知道，我们传统上，它是使用网络接口卡完成的。
嗯，这是一张像这样的卡，你现在会在服务器上找到，如果是笔记本电脑，它真的缩小到了一块木板上的芯片，你通常会发现有线或无线接口，一些旧卡中的数据是如何传输的，它是通过使用编程的，我喜欢新的卡片，是DMA。
所以dna是传递数据的机制。
这将在互联网上进行一次漫长的航行，从主存，当它到达目的地时也是如此。
它的网络接口卡将使用dma将其传输回内存。
就这样了。
我们就把这个模组，我们又做了一件事。
我们在了解计算机工作原理方面又迈出了一大步，我是说我知道我们都知道电脑是怎么工作的。
但我们现在真的知道它们是如何工作的。
我们还弄清楚了工作是如何进行的，我们如何与它互动。
我们确实需要上更多的课才能真正编写一个操作系统。
我们可能不需要那么做，我们可能会很高兴只知道如何互动，并选择一些其他的类，第一堂课是。
我们还在这个过程中建立了一个虚拟内存系统。
并弄清楚了各种物理设备是如何工作的，为什么我们有。
不同类型内存的速度和可负担性。
所以我们得到了为什么我们必须在这里建立这个大内存的物理原因。
所以我们可以建立这种无限快的幻觉，和无限大存储系统，最后。
我们知道了如何连接外围设备来执行输入和输出。
同样的机制用于。
和以太网卡连接到世界其他地方。
整个模组就到这里。
