UCB-CS61c-组成原理中文笔记-五-

UCB CS61c 组成原理中文笔记（五）

P30：Lecture 23： RISC-V 5-Stage Pipeline III,Hazards - 这样好__ - BV1s7421T7XR

拥有这一切，还有期中考试，所以这周请务必参加实验室，另外请填写期中考试复习表，或者在期中复习表上，就像丹在第一节课上说的，这是一个实验，在不同的时间亲自做，你们在实验室里做了，也用那个巨大的窗户带回家。

为了你，真正感受并建立你对风险五和风险C的信心，请让我们知道我们将来在这方面需要改进什么。

关于期中考试的其他注意事项，我想乔和公司是什么。

是的，公司发布了这篇教育帖子。

而且这些幻灯片应该很快就会出来，如果他们还没有，请不要谈论任务，还有几个学生在上，而且我们还没有写出解决方案，或者更确切地说，是对我来说，我们还没有为你们所有人发布解决方案。

但是当你被允许谈论期中考试的时候，我们会让你知道的，如果您在紧急情况下有任何与考试有关的问题，对此感觉不太好，不管怎样，请发邮件给我们，在伯克利大学六十一C给我们发电子邮件，我们可以帮你安排。

我们就能知道在这学期剩下的时间里什么对你有用，如果你喜欢，最后一件事，但在期中考试的这段时间里，现在你真的很担心赶不上课程，也许是因为期中考试后我们也讨论了很多内容。

请务必报名参加学生支持会议，您可以通过扩展表单来完成，谢谢你，我们期待着在这门课上继续支持你。

希望你能感受到我们61C家族大滑梯的支持，这真的只是一个顶级声明，你得仔细阅读每一个细节，但是我们有首尔国立大学的李杰教授，他实际上是作为实验室会议的一部分来发言的，所以当呃，当你这么做的时候。

当你读博士的时候，或者当你在那种学术环境中，你有不同的研究实验室，这并不总是意味着人们在做，你知道，就像生物学，实验类型，有时他们在设计gpus和这些不同类型的设备。

所以切片实验室实际上是一个领域特定的架构实验室，所以围绕不同类型的应用程序设计，在你们今天看到的所有处理器中，然后呃，李教授现在要在，呃，让我们看看一般的域特定硬件，如果你看了他的简历。

他真的读了博士学位，在这个地区，在另一个机构，也在谷歌呆过一段时间，所以我认为这将是伟大的，呃，这是这是变焦，我可能也会在周三的课上分享它，话虽如此，你们中有多少人复习了星期五的课，或者喜欢。

看了星期五的讲座很酷，所以我看到90%的人，没关系的，如果你不确定的话请举手，我们要做一个快速回顾，因为我知道每个人都有点回到这些事情上，期中考试之后，然后我们会我们会跳到这些事情的其余部分。

我们称之为危险，但在我们谈论危险之前，我想提醒你我们在这件事上的位置。

调用管道数据路径，那么管道数据路径有什么不同呢。

这是当不是只有一个指令，可以按顺序执行所有阶段，我们实际上有多个指令共享管道，然后我们思考这个问题的方式是，假设我们有一个加法指令紧跟着一个子指令，假设我们在这个特定的时钟周期中，当我们看到这个小的。

类似管道梯形图，这里是add指令当前处于执行阶段，在ALU阶段，所以目前使用管道的这一部分，然后子指令使用ID阶段，就是这个指令解码阶段。

这实际上意味着它正在访问寄存器文件，为什么我们可以让这些指令共享相同的管道，我们可以有这些叫做管道寄存器的东西，保存这些数据，所有指令的数据，然后在成本上升的边缘，把它冲洗出来。

以便能够让指令使用那个阶段，如果这有点像快照点，允许所有这些指令数据共享同一组导线。

但请注意，实际上有几个，呃，这里有一些叫做危险的东西。

特别是在我们的添加和子的情况下，现在我有三个指令，我还遵循了这个叫做或和或指示的东西，我们有这些叫做危险的东西，当一些指令在那里，实际上还不能正确执行。

因为它使用的源寄存器为零，它使用第四个寄存器为零，在之前的指令中写到的，我们知道如果我们把所有的细节都流水线在一起，然后零寄存器直到第五周期才会被写入。

如果我们从一、二、三、四、五开始。

如果那是第五周期，嗯，实际上潜艇在上一个周期需要它，就在这里。

因为它需要添加，或者你需要用t零减去s零。

它实际上是这里正在发生的事情，那井是在身份阶段吗，它读错了值，s零的旧值，在幻灯片的底部正好有五个，它不会更新到，假设新值，哪个是哪个是九，直到它被写回这个WB。

好啦，所以这就是这里的危险，Sub实际上不能与。

或者也读取错误的寄存器寄存器值x零，因此，从技术上来说，它也不可能发生在那里，因为有一种叫做数据危险的东西，它得到了错误的数据，那么解决办法是什么呢，嗯，我们最后一次谈到，这就是我们的结局。

我们谈到了一个叫做拖延管道的事情，换句话说，遵循一些指令，使它们实际上不执行，在他们等到没有更多的数据危险之后。

然后他们就可以跑了，这看起来像是当潜艇，有一些解码发生，然后，然后管道实现，哎呦，其实呢，我现在还不能开潜艇，因为我正在读的零还没有被写到更新，所以它让这些东西沿着管道冒泡，对于这个图来说。

这到底意味着什么，M，就我们的理解而言，管道阶段只是运行垃圾数据，所以它只是运行垃圾数据，它实际上并没有写任何东西来更新其他地方的所有状态，然后在第二盘的第二盘也是如此，它试图再次运行潜艇，但这就像。

啊，好啦，好吧，又来了，因为零还没有被写入，我没有S0的正确值，然后我要去努普，否则我会冒泡或失速，最后在这最后还是在这，呃，在倒数第二行，现在是潜艇，在这一点上，当寄存器文件为红色时。

将在此ID阶段从中读取，这个指令解码阶段很好，它发生在同一个循环中，当寄存器文件被写入后台右侧时，因为上次的寄存器文件是一个写，然后读这个可以发生在同一个循环中，所以这很好，最后一条指令。

或者在这一点上，嗯，我们肯定知道F0没有被写入，所以我们可以，我们可以像平常一样抓住它，有时讲座结束后会出现一些问题，感觉还行，嗯，就像，这是怎么发生的，这些泡泡是怎么起作用的。

你可以想象在之前的图表中，如果我很快回到上一张幻灯片，如果我很快回到上一张幻灯片，只需添加更多的电线和添加更多的块。

并添加更多通过管道寄存器布线的项，还记得上次我们谈到控制。

通过管道寄存器转发，大家可以想象一下，也有一些没有操作的谎言正在通过寄存器转发，以确保我们不会将任何内容更新到我们的状态文件中，像寄存器和内存，但是，事实证明，这实际上是一种昂贵的，就时间而言昂贵。

因为这意味着在接下来的两个周期里，你不能实际执行这些指令，你的整个管道都停止了，没有执行或没有执行，没有完整的，否，没有一个指令是完整的，所以转发是另一种硬件解决方案，实际上显式地有线连接。

管道的输出登记到不同阶段的不同部分，换句话说，在上一个版本中，我们在上一张幻灯片中，我们在考虑我们只能从寄存器中读取值，当它们都正确更新时，但我们知道，由于我们的五级管道，到那时。

到了第三季的时候。

我们确实有什么，结果f 0的值是正确的。

在舞台的最后，在此执行阶段结束时，因为零是g零加t一。

然后这个值通过dm，男人们，男子舞台，然后在后台写到右边，但在最后两个阶段并没有改变，所以所以，如果有一种方法可以直接连接前阶段的输出，前阶段的输入，然后我们就可以知道在下一个周期。

当我们执行子指令的alu部分时，我们实际上可以用S0的正确值执行，这是一个这是一个巨大的一口，但让我给你们看另一个例子，也就是说，在这一点上，让我们来看看OR指令，所以这个或指令有效地。

我想说的是在执行阶段，我们只需要知道零点的正确值，因为这是操作数之一，源运行良好，我们什么时候知道正确的值，嗯，从技术上讲，它是在前阶段写的。

但我们在后台的时候就知道了，但我们知道前男友的广告，广告的前任发生了，所以如果我们有类似，如果我们要把s零转到mem阶段。

因为它最终会被写到，右后卫。

我们可以把输出连接在一起，这是零进入或的执行状态，我想，老实说，这可能是所有图表中最具挑战性的图表，我们要在蔚蓝区做的，因为这里重要的是要知道，这就像是同一条管道。

好吧，就像我刚刚重复了三次管道，但这是同样的硬件，那么转发是什么意思呢，转发意味着结果及时转发到某个未来值，所以在这种情况下，我们说E，x在时钟周期三中添加EX的结果。

转发到su的ex和focycle four的输入，而不是等到时钟周期五，它被写入这个寄存器文件，然后同样地，或者它从这个男人的舞台转移到前任的输入中，第四阶段或，所以时间是向前的，是呀，有个问题，呃。

是呀，是呀，问得好，是呀。

所以有一个问题就像嘿，嗯就像，我们不能喜欢这里的紫色电线吗，从技术上讲，它来自记忆。

那是怎么回事，为什么它会变成x，它不应该从这里一路连接吗。

这是一个很好的观点，其中一些只是基于事物是如何连接在一起的，我想这里的重点是如果你把镜头拉近，让我们看看我能不能放大，我可能无法，但你会在幻灯片上看到的，没有，我不能放大，如果你把镜头拉近。

我要退出，你会看到我的秘密幻灯片，与所有不同的梦想，如果你把这里放大，您将看到我实际上使用了管道寄存器作为，电线从哪里来，好啦，所以你可以在这里看到，正在发生的是，它没有直接连接到ALU的输出。

或直接连接到M的输出，它真的来自我拥有的任何一组管道寄存器，因此，如果我们回到最初的幻灯片，你可以想象Alu值是在e x中设置的，这些紫色注册的英雄，以及这个MWB管道寄存器，所以所有这些都有ALU值。

电线就是从那里来的，实际上，让我们看看，让我们在下一节中看看这个，所以我要向你们展示转发是如何工作的，对于其中一种情况，这是广告子，我不会告诉你潜艇或一个是什么，是啊，是啊，我会，我让你自己想办法。

就像在喜欢，我尽量保持图表相对简单，因为它们非常复杂，但让我们再来看看这个，我们在想什么，我们在考虑这个案子，然后换人，然后我们从x值，这个特殊的管道寄存器，所以存储ALU当前结果的东西。

我们试图将它直接连接到ALU的输入。

所以即使我们在管道上及时转发了这个，数据路径，实际上看起来事情在倒退，因为我们处理的是同一条管道。

每个人都在使用相同的管道，如果我们想转发ALU的结果，让我们看看这是如何工作的，尽管该值存储在ex mem管道寄存器中。

好的，好的，中间这个。

让我来，现在让我强调一下，如果是这样的话，我们需要以某种方式连接这个管道寄存器。

我要留着，当这两个Muhere。

因为它最终会被加入，那么这是怎么发生的呢，只是有些电线。

所以我要把我连接在一起的东西，这里是，我说。

好啦，在内存中的管道寄存器输出，在记忆阶段，会发生什么，它要接上电线。

然后狼吞虎咽，连接到这两个标记，选择ALU输入A和B。

这里还有一些关于我当前指令的信息。

那么这个紫色的指令是什么，这是添加指令。

这里的蓝色指令是什么，它被转发到控制逻辑，这是第二条指令的子指令。

然后转发控制逻辑会做什么，就像是。

好啦，嗯，我知道铝的价值，哪个是输出，也就是f为零，它将需要用作源输入之一，事实上，输入ALU的A，为了下一阶段，为了下一步，那有点，这个文件是怎么回事，你有什么问题，是啊，是啊，我认为就电线而言。

这可能是最具挑战性的，因为在数据路径中，电线倒过来了。

紫色的线在向后，但在梯形图中，箭头是向前的，因为你在，我们在这里有什么问题，好的问题，是的，是的，是呀，是啊，是啊，让我回到上一张幻灯片，不幸的是，我的颜色在这里不完全正确，所以我可能会有点困惑。

呃，是否，到了上一张幻灯片，我们在这里做的是，我们把注意力集中在绿盒子上，我们在说，好啦，我们真正需要的是结果，它位于x和mem之间的管道寄存器，这需要转发给输入，E X阶段，因为从技术上讲。

前阶段是完全相同的X阶段，它只是被执行，每个周期，发生的事情是那么好，EX或管道寄存器的输出，就像回到X输入的电线，但随着时间的推移，至少在时间上，作为这条管道，就像这个特殊的梯子图。

我们看到事情进展顺利，所以这就是为什么我认为这是一个挑战，那么转发的是什么，平均转发意味着及时转发，这样你就不用等着写东西了。

我们将在，呃，这里的下一个例子。

也就是负载，所以让我们看看会发生什么，就像我说的，当我们试图喜欢，比只把东西写到寄存器文件更快，只有在正确的后台才会发生，让我们把这组特殊的指令，从添加到加载字到是否，然后左移，逻辑，在这种情况下，嗯。

我在这里突出显示了一些寄存器，我们可以，实际上他们可能有数据危险，但我们要通过把硬件，或将逻辑转发到我们的数据路径中，所以让我们看看，让我们看看转发可以修复的两个危险。

哪个是更多的硬件和更多的转发控制逻辑，其中一个在广告中写为零，所以更新s零的值，但在下一条指令中立即阅读，所以再一次，如果我们没有转发，这意味着我们必须把所有的管道，在零点之前一直有负载，但是。

因为我们确实有转发，我们会知道到那时，s或t一加t二在前阶段计算，我们可以直接把这个转发到e x阶段进行负载工作，现在为什么加载Word在执行阶段需要零，我们把八加零相加，只是记住负荷工作是如何工作的。

所以这很好，就像在绿色盒子里一样，如果你没事，这里的1和1怎么样？加载字指令中的一个是什么。

让我强调一下，让我看看我能不能做到，这里的一个是我们记忆单词的目的地。

或者像这样，我们的记忆字将生活在寄存器文件中。

所以第一个会在后台更新，但真的，它将在记忆阶段结束时被知道，在这种情况下，只要有一个，或者就像f 0加上8的值，就像你知道这个词在那个地址的价值一样，一旦这个词从内存中加载，从技术上讲。

我们需要在下一阶段把它写到s one，右边后台，但在这个时候，一旦内存字被加载到数据路径中，我们知道它的值是多少，所以我们可以把它作为一个来源转发给，所以这就是为什么你可以看到这根电线。

上面写着好吧，这就是一个值将被知道的地方。

我将需要它为ALU的输入在执行阶段。

好的，所以这就是我们所看到的。

这就是我们在这里看到的蓝色盒子，所以转发解决了这两种情况，因为否则我们将不得不等待另一个周期或拖延另一个周期，右后方写着，转发喜欢是快捷方式。

然而，这里有一个数据危险是四十个不能解决的，所以记住，好啦，当你看到这种类型的图表时，你的口头禅是什么，恰逢其时，转发及时向前，现在让我们看看这个特定的数据危险会发生什么，上面写着好，加载字。

S的一个将被写在后台的右边，但我们会在记忆阶段结束时知道的，但是，或者在E X阶段需要S一个，哦不，这是做什么的，你记得我说过的话，我说过MEM阶段的输出，就像那种管道寄存器，它将知道s的值。

但我们需要这个来输入牛阶段，所以这个箭头是时光倒流，没有进展，那么这里的问题是什么呢，到底发生了什么。

这里到底发生了什么，在相同的时钟周期中我们需要输入，它实际上是其他一些数据路径元素的输出，好啦，所以换句话说，这里的mem数据路径元素需要以某种方式向前向后。

或者像你知道像你知道，所以说，如果我们想想向前向后的事情，这个不太有道理，所以这实际上是不可能的，好啦，为什么物理上不可能，为了让这种情况发生，为了做到这一点，我们可以有这根电线。

我们需要像DM访问这样的MEM首先发生，然后是e和e x，就像alu，需要能够执行，较低的时钟周期仅是ALU或DM访问的长度，所以我们的时钟周期不够长，所以我们可以把这些东西连接在一起，我们该怎么办。

答案是。

当货物发生时，我们真的无能为力，没有硬件解决方案来修复这一个失速，我们有一个额外的摊位，给大家看一下，我来教你这个，呃，这在实践中是如何工作的，好啦，就硬件不可避免地要做的事情而言，因为我们不能后退。

对呀，因为我们不能把时间倒过来。

取而代之的是，当我们看到这个，或者我们知道我们无法在执行阶段及时得到s 1的这个值。

因此，我们将知道它，好的，好的，所以我们在这里称之为指令，我们称之为，负载延迟槽，暗示这就是延迟发生的地方。

所以一旦我们看到或这是这是，这就是我们一看到这个就要做的解释，或者它使用加载字的结果，哪个是S，然后它必须知道选择它，因为它知道它不能对我执行，当字的值仍从内存中加载时，它无法运行其执行阶段。

所以它必须再等第二个周期，然后在这一点上，它能够向前做，你在这里有什么问题，哦哦，伟大的洞察力，所以问题或洞察力是，好啦，所以如果加载延迟槽没有使用加载字的结果，那就不会耽搁了，是呀。

我们会在下一张幻灯片上看到，所以至少每个人都明白，或者还好，我要做的像点头，在这里检查，所以至少每个人都明白，如果我们有这种依赖性，在需要使用或指令的地方，作为一个我们不可避免地会有延迟。

我不需要做或不做，好啦，我们得到了，我们有一半，不在这里，我们会得到这个在这里，哦耶，还有一个问题，哎呦，只是为了所有人，为任何事或任何事，但接下来，是呀，另一个问题，是呀，哎呦，好问题，是啊，是啊。

这里有一个关于程序计数器的问题，这个noop到底会发生什么，所以禁制令真正做的是，上面写着好的，请不要实际更新程序计数器，因为我需要再次访问该指令，是啊，是啊，这是个好问题。

所以你也会把这看作是讨论的一部分，就像没事一样，嗯，如果需要重新加载上一条指令，个人电脑加四个，您不应该更新到下一条指令，因为那样你就会失去一切，这就是失速逻辑实际上为你实现的东西。

但就像它是一种方式或比什么更低，我们做了很多，好啦，所以让我们回到那个想法，这没关系，对于加载后立即使用加载结果的任何指令，我们将需要解决，但其他一切都会好起来的，这允许我们做什么。

看看我们的风险五说明书，试着重新排序，这样负载延迟就不会发生，这就是在代码编译阶段完成的，通常，在硬件级别上可能会发生一点重新排序，我们今天下课后再谈，让我们看看，所以让我们假设这是我们的C代码。

我们有几个数组访问，一个零，一个一，一个二，我们把它们加起来，然后我们把它们存储到同一个数组中，这在简单的编译案例中是什么样子的，所以让我们假设我没有考虑很多，像我这样的编译器，我没想太多。

我在想把c转换成风险五，我可能会做的是。

我会先装一个，我把它放在一个，我会装一个二，然后把它放进第二个。

这就是为什么那里有绿色价值，然后我会加一个1和一个2，又名零加一，也就是T 1和T 2我会把它存储到T 3，这是那里的前三个指示，然后我们的前四个指令。

然后我会把一个2装进T4。

然后把它们相加并存储这个值，呃，一个四，它需要在哪里。

然而，这会导致延迟，因为我们有一个行动，在这种情况下，紧随加载之后的add操作使用类似的值，使用t 2，使用加载字的结果，因此，在硬件层面上，这不可避免地低了一个层次，会造成延误，同样地。

同样的事情在7到8号线又发生了。

即加载字T 4的结果，这就是我们这里的A R A2，需要立即被读取为下一条指令的源。

所以这不可避免地会造成延误。

没什么大不了的，只会降低我们的表现，好啦，这其实是件大事，就像，哦不，是呀，问题，好啦，所以问题是关于游戏的，以及装载需要什么，这个稍微有点不一样，嗯，是啊，是啊，我很乐意事后再谈，这是说在汇编。

就像中央的柱子一样，此代码可能发生，这就像是完全可行的代码，它会正常执行的，只是执行得很慢。

那么什么是更好的汇编呢，如果编译器知道会有一个循环，延迟一个循环失速，然后它可以尝试重新排序指令，这样这些摊位就不会发生了。

我们去看看，我在这里做的唯一一件事，我把第三个加载字指令的集合，也就是我在访问一个2的值，我把它提前了，好啦，所以我有，我从数组中加载所有三个元素，数组元素零一和二，然后我添加它们并将单词存储在一起。

所以这将允许我做什么，现在不再有立即使用加载Word结果的指令，在他们的负载延迟槽里，这让我能做的，结果是什么呢？这是加载延迟后的一条指令，因此，只要我的管道有40个，这个问题就可以解决，是啊，是啊。

好啦，有一个问题要回答，因为你必须看起来像，是啊，是啊，是啊，是啊，这是个好问题，所以问题是如何编写编译器来使其工作，答案是很多很多人，是啊，是啊，但实际上更重要的答案在左边，也就是说。

您需要知道CPU正在处理的管道，因为如果你不知道负荷发生在第四阶段，处决发生在第三阶段，那你就不知道怎么重新排序了，所以这种事情，是啊，是啊，我要去，之后我要回答几个问题，但我还需要完成一个部分。

谢谢好的，这又是两个部分，好啦，所以这很低，然后你可以看到我们完全建立了我们对管道情况的了解，处理危险，现在我们有另一种危险。

我们上次简短地讲到的，这就是所谓的控制危险，所以我们又到了这里，这里危险的定义是什么，这意味着我们在技术上无法执行该指令，所以我们需要以某种方式解决问题，否则，我们看到管道降低了性能。

我们说过有两种危险，结构灾害，因为我们一开始是如何设计我们的管道的，然后数据危险，我们已经讨论了三个类别，其中一个是正确的，然后读取硬件解决方案，其中之一是转发解决方案，然后其中一个就好了。

我们需要在编译器级别上解决它，所以再高一级，好啦，带代码调度，我们再聊一个，这就是所谓的控制危险，危险控制说我们接下来要执行的指令，取决于我们执行哪条指令取决于当前指令的结果。

那么这种情况发生在哪里分支。

我在这里只讲一种类型的分支，因为这会让讲座变得简单一点，我将讨论条件分支。

所以条件分支，分支机构，你可能还记得，计算几件事，好啦，所以如果我们考虑一个b q源1，强制两个标签，它检查源1和源2是否相等，如果是这样，它会将PC更新为PC加偏移量，所以这里需要进行几种计算。

其中之一是分支比较器，它检查rs是否为1和r 2是否相等，然后它转发它来控制，另一件需要发生的事情是PC需要立即添加到一些，这在ALU中有效地发生了，这对我们的管道意味着什么，所以请注意。

我喜欢谈论事情，就像现在的访问级别，那实际上是故意的，这对管道意味着，通过我们的管道寄存器，是啊，男人，我们知道更新PC 2的价值，因此，在MEM中，在MEM阶段，这是PC更新的地方，我只是想让你知道。

那么什么是，这里的幻灯片有什么意义，这里滑梯的点，分支结果是在MEM阶段计算的，所以在那个阶段之后，然后我们就能够执行正确的指令，这就是导致控制危险的原因。

让我们来看看这个，让我们假设我们有左边的代码。

略有不同，它基本上是从一个分支开始的，等于，有几个说明，次级或F或发生的，然后有一个商店的词发生。

但是请注意这些说明的地址，好啦，这些就是指令地址本身，由男子状态，那么发生了什么，在这两者之间，呃，在这些更新之间，所以好吧，你可以在下一个阶段看到这里的箭头。

这是当我们得到正确的电脑为下一个教学，但这意味着中间的三条指令。

这是控制危险，因为这些指令执行得不有序，他们不应该被处死，但是为什么要执行呢因为前三个阶段的指令提取，它勾勒出了下一个指令PC加上四个PC，加四台电脑加四台以此类推，直到PC被明确更新。

分支的MEM阶段等于它得到了正确的PC，就是PC加偏移量，在这种情况下是7哈希十六进制7，所以这是一个控制危险，因为中间的三条指令，那么这里的解决办法是什么呢，不可避免地会有延迟。

所以事实证明，这也不是通过硬件解决的，但我们应该做的是如果这些指令开始执行，我们知道他们不应该喜欢这些结果，不应该发生，我们应该我们应该泡泡，我们应该在他们的舞台上泡泡。

我们需要确保他们的结果不会被写进，写入重新归档，写在记忆中的一切，好啦，所以我们这样做的方法是我们把这些疯狂的部分，我们在过去没有谈太多，使这些结果不会发生，好啦，所以我们在这段时间里浪费了管道。

但至少我们没有写我们应该写的东西，因为这将是这里的危险。

是啊，是啊，你不是在做一些指导吗？你知道你意识到这些泡泡有点。

呃，就发生的事情而言有点不一致，想象一下这里，只是意味着无论结果如何。

不应该在下一阶段被写出来。

这里的这些舞台，是呀。

问题好的，所以这里的问题是好的，是在这些指令上获取的。

或者在这些指令上仍在发生，你不是还在接受下一条指令，还在更新电脑吗，是呀，答案是，这是唯一一个碰巧被更新的状态。

不过，谢天谢地，只要结果和右后卫。

只要这些没有写入内存和reg文件，如果ALU执行垃圾也没关系。

如果我们在红色的时候读垃圾也没关系，指令解码时。

因为什么都写不出来，是呀，个人电脑除外，这是正确的，这是正确的，是呀，所以这里的澄清是，所以PC是递增的，你可以在左边看到这个，我用鼠标，你可以在左边看到这个，PC确实在增加，就像。

这就像因为指令获取发生了，然而，在此指令发生之前，PC将在此更新，因为在男子舞台上发生的事，是啊，是啊。

这是一个很好的澄清，谢谢你，哦耶，那是我的，哎呦，我喜欢这个，是呀，好问题，好问题，所以我偷偷地试图避免，因为一想到，但现在你又提起我所有不好的回忆，所以让我们稍微讨论一下，所以这里的问题是，嗯，嘿嘿。

PC不是因为像这样的分支而更新吗，这是你在一个周期内告诉我的，对呀，然后在一个循环中，会发生的是整个过程，我们知道分支会是什么，然后我们更新电脑，在管道阶段有什么不同，在流水线阶段的不同之处在于。

这个指令获取，此指令提取阶段为零，对以后其他阶段发生的事情的了解，所以你能想到的是，指令提取与单周期情况的差异，所以管道指令提取是PC总是更新到四个，除非某个更伟大的人告诉我单独更新它，好啦。

所以这意味着什么，让我向你们展示一下后一张图，所以这对我来说总是更容易让我们思考，因为我们现在看到了所有这些不同的指令，当分支等式执行指令时，去拿，PC将更新为PC加四，因为不可避免地。

它现在还不知道它是否在分枝，类似地，在Sub中，当我们执行这个指令时，获取，PC不可避免地会去更新PC加4，因为它还不知道，然后现在在或指令提取仍然上升到PC等于，PC加4以此类推，直到真正发生更新。

就发生在这根电线上，那是我们透过这一页看到的紫色电线，那么在控制逻辑方面发生了什么，就上次延迟的所有结果而言，是这里发生的PC选择吗，这只标记为一个如此拍摄的，当我们知道分支已经计算出正确的。

消息中的正确值，是啊，是啊，所以有点乱，这就是为什么我们得到这些额外的指示，这种控制危险，这是常有的事，那么解决办法是什么呢，解决办法就是解决，我是说我们稍后会看到一个更小的稍微改进的解决方案。

但这里的解决方案是，控制危险是什么，控制的危险在于，这三个指令发生在分支子或x之后，或者不应该执行到完成，因为如果他们完全执行，那他们执行得不正常，那我们该怎么办，我们停下来，我们只是说好吧，嗯。

不管这些指令的结果是什么，我们应该只是喜欢，只是不要用它们，他们会发生的，因为PC正在更新到PC，加四，因为直到这个阶段，我们才知道PC会是什么，但我们应该确保它们不会被写入注册文件，致。

那我们该怎么办，这似乎是不可避免的，每次我们做一个条件分支，实际上是一个正规的分支机构，以后再说吧，但是每次我们至少做这个条件分支，我们得等三个周期才能知道分支到哪里。

注意，如果我们不把树枝，然后之后执行的指令，他们无论如何都应该执行，所以那里没有危险，不过，感觉还可以，嗯，有时会有危险，就看我们接不接枝了，还请注意，我们在这节课中说，分支需要三个循环。

实际上有一种方法可以做一个循环版本，我们不打算在课堂上谈论，有一点。

它是，它实际上完全超出了范围，但如果你有兴趣，一定要读课本，但是我们能做的，请记住以前的负载解决方案是如何的，我们什么也做不了，我们只需要拖延和前进，然后我们可以在编译阶段做些什么，在这种情况下。

我们的解决方案是尝试在硬件层面上进行某种概率分析，就是做这个叫做分支预测的事情是什么意思，分支预测意味着好，像之前一样，我们知道分支的结果，我们能不能预测一下，下一条要执行的指令是什么。

然后如果可以的话，然后我们会喜欢，你知道平均来说，希望我们能预测正确的指令，所以我们不会再耽搁了，它来自于走错路，那么我们怎么做呢，这里有一个例子，我们已经有效地拥有的管道，分支预测，好啦。

从某种意义上说，它做了不拿树枝的预测，让我动一下，你可以在这里看到标题，预言说我们只是要预言我们永远不会拿走树枝，为什么我们可以说这就是预测的结果。

让我们来看看我们的管道，分支之后的下一条指令是什么，这是发生在十六进制四的子指令，这是我们应该执行的指令，如果我们不拿走树枝，所以从某种意义上说，这是我们的喜欢，我们天真的预测者总是不接受树枝。

所以这就是我们做的对，如果我们不拿树枝，我们不拿树枝，然后突然就像，也许在这个里面，哎呦，碰巧的是，我们确实有，不要拿树枝，然后我们得到它，我们其实这些。

这些数字稍有偏差，因为我忘了怎么做，如何添加数字，查看所有，你知道的，我不参加期中考试，所以在这种情况下我们说，好啦，平均。

至少，我只希望我永远不会走桥，那实际上是，我们正在使用的天真和常规的管道，所以在这里，所以这三个指令，如果树枝真的没有被拿走，这三个指令将执行，所以我们没有浪费，现在这是完全正确的。

如果在最后一条指令中，我们刚好把树枝，然后我们将有重量通过三个循环，那是不可避免的。

啊，是啊，是啊，看你像丽莎，还是不能做他，谢谢你，四英尺，我把它固定在前一个，然后在5点0分，看看你们，好啦，嘿嘿，好啦，酷，所以它在这下面。

所以这有意义吗，那么这里的目标是什么，让我搬到这个盒子里，我们的目标是如果我们错了，我们仍然需要三个周期，如果我们有一个更好的分支预测，这总是正确的，但至少我们可以降低这三个周期的平均成本。

我是说你可以计算出，如果你想，我们不打算进行概率分析，那么我们对控制危险有什么感觉，没有，网上有个问题，哎呦，好问题，我们可以使用代码调度吗，不知何故，那么我们可以做很多与分支有关的编译工作吗。

这是个好问题，有点复杂，答案有点复杂，我们可以使用代码调度吗，或者不记得整个冷冰冰的日程安排，这些指令无论如何都要执行，所以让我试着重组它们，这样他们就不会因为他们的数据而造成延迟。

这就是我们在课堂上的看法，但是，我接下来要讲的是一种方法，就像那种推测性的日程安排，这样我们至少能够执行一些可能发生的指令，所以答案不是。

不在这部分的范围内，所以我们到目前为止所说的，我们已经讨论过风险五的五阶段管道，为什么我说这是风险五的五阶段管道，它是基于ISA实际上允许我们做的所有这些很酷的事情，使流水线得以发生，例如。

所有指令都是三个二位宽，所以它总是可以准确地知道什么指令可以读取，它总是访问四个字节的内存来读取指令，这张幻灯片上的其他东西，加载存储地址是这样的，您可以在第三页中计算地址，我们到了，我们就在这里。

我们用ALU计算地址，然后在之后的下一阶段，在第四阶段，那就是我们进行内存访问的时候，幻灯片上还有别的东西，但你可以注意到我们描述的方式，如何设计数据路径，从概念上讲，每条指令都有五个状态步骤。

所以这很好，事实证明，这条管道实际上用于许多不同的设备，事实上，可能你正在使用的80%的设备都使用五级管道，某处，好啦，就像你是你的微波炉，你的车，如果你有车，你朋友的车，滑板车，就像我们周围的一切。

因为我们周围有这么多设备，现在他们都用五阶段的皮亚特，一个原来就像，好啦，你的手机，你的iPad，或者你的平板电脑电脑什么的，它们也有五级管道，但他们也有更复杂的管道，这就是我们如何改进这些。

喜欢电脑设备有更好的性能。

所以这里有三个选择，通话率。

管道深度和超标量处理器，让我们简单地谈谈他们中的每一个，我只是想把所有东西都放在我们谈过的同一个幻灯片软件上，如果我们有硬件，如果我们有快速的技术，然后我们可以提高时钟速率，但是我们不能增加太多。

即使我们的硬件真的很好，因为一个叫做能量耗散的东西，我们不知道如何冷却芯片，使一切都能正常运转，我们不想喜欢，进入超速状态，或者像融化我们的芯片，所以这个是可能的，但也导致了一些，一些，一些挑战。

这就像如果你把集成电路，或者如果你更偏向一边，这是你可能会经常处理的事情，一种选择二，这里是你增加管道深度，上面写着好吧，在我们的情况下，我们的风险五指令集，我们从不在指令的执行阶段上重叠，对呀。

每条指令或每个阶段一次只能由一条指令使用，我们可以重叠，就像把这些阶段分成更小的阶段，用更长的管道，更深的管道，像十个或十五个阶段什么的，这将允许每个阶段更少的工作，哪个能提高你的时钟频率。

这些数据危害的可能性更大，这些控制危险，我们所说的这些结构性危险，所以由于引入的延迟，每条指令将发生的附加循环，它实际上增加了我们每完成一条指令的周期，好啦，CPI，请记住，说明已完成。

因为每条指令都可能有额外的延迟，与之相关的额外粒子，这并不总是我们想去的地方，我们今天要简单讨论的第三个问题，然后我们会更深入地讨论，几周后就是所谓的超标量处理器，这实际上是很多台式机。

今天使用的手机和笔记本电脑，我们谈谈吧，真正的简短。

标量处理器有两个优化，至少相较于五个阶段，圆周率总是如此之远，一次又一次，这部分的想法就像最后几分钟，我们要从更高的角度来看待这个问题，所以你知道你的电脑和平板电脑里发生了什么。

只有两件事是超标量处理器做的，其中之一是它在每个时钟周期执行多个指令，它通过向不同的管道发出指令来做到这一点，不同的硬件管道可能都有不同的，呃，发展阶段，呃，与他们有关，所以说，例如，在右边的图表中。

我们有一个整数管道，一种类似于加载整数并将它们相加的方法，把它们储存起来，我们有另一个整数管道，我们还有一个浮点管道来计算浮点，也许我们有一个单独的负载存储管道，因为我们想设计我们的管道，这里，在最后。

我们把所有这些指令组合在一起。

这就是所谓的动态无序执行，决议，或提交单位，所以这里有几个音符，这有点像中间的蓝色子弹，如果我们每个周期执行多个指令，下去，因为在最好的情况下，如果我们这里有四条管道，这四个指令都执行了。

然后我们就完成了四个指令，职业自行车，就像零点，两个，每节课完成五个周期，你可以看到这里有进步，然后再一次，提交单元所做的是，你可以想象这些指令，我们不知道他们是否互相依赖。

因此提交单元将允许我们解决其中的一些问题，刚才提到的一个问题，所以这有点像硬件指令并行，我再过一分钟，只是为了告诉你这在实践中是如何工作的，至少从CPI的计算来看，也就是说，让我们把这个真正的芯片。

它是一个ARM处理器，这是一个五三，假设它有一个，假设那是两千兆赫和双问题，这意味着它的峰值dpi将是零点五，因为学员每个周期最多完成两个指令，然而，峰值cpi是你看到的实际cpi。

那么人们实际上是如何测量cpi的呢？它们在您的计算机将使用的实际不同应用程序上使用所谓的基准测试，像视频压缩，网络仿真。

所有这些类型的事情，然后他们用这个公式，铁律，我们都知道，我们用cpi，我们知道是因为你的硬件是如何创建的，每个程序的说明，如果你有基准，你很清楚基准是什么，他们说很多开发这些的人都知道这个基准。

这些处理器，你知道会有多少行代码，你只要运行程序，然后你测量程序所需的时间，你只需围绕这个公式进行划分和转移，从基准上衡量事物，您可以将CPI计算为每个程序的时间，除以每个程序的指令数。

乘以成本比率的1，让我们看看图表，这是最后一面，我为过去的时间道歉，这里cpi等于1，这个酒吧，理想CPI就在下面，那是零点五线，这就是cpi的峰值，上面写着，好啦，最佳，我们每个周期可以执行两个指令。

但实际上，我们在这里说，视频压缩，H二六四，呃B拉链二，就像文件压缩一样，最小成本流，基准说你的实际消费物价指数账户比一个大得多，所以有更多的危险，实际上还有很多处理内存访问问题的方法。

这就是我们下次要讲的，太感谢你了，我们星期三见。

P31：Discussion 8： Pipelining, Hazards - 这样好__ - BV1s7421T7XR

所以我们身后的期中考试，我们都结束了，每个人都过得怎么样，好啦，一种新的考试形式，嗯，但与其他考试相比，行吗，令人困惑，这肯定比像十六系列考试要好，我不知道，我是说，在过去的学期里，他们必须喜欢手写。

C代码，没有人喜欢，所以希望带回家的部分更容易使用，嗯，回到课程负载，我们星期三有第三个项目，嗯，希望你们能从这个开始，尽管与整个项目相比，A部分是相当小的，所以你应该有良好的信誉。

今天我们要谈谈管道和危险，你们中有多少人参加了上周的讨论或观看了上周的录音，我觉得你们很多人都在准备期中考试，好啦，我们将温习一下上周的材料，但是嗯，大多数时候试着直接去做，所以说。

我们现在正在使用管道数据路径，我们在数据路径中注入了额外的寄存器，使我们的临界路径更短，希望这将优化我们的数据路径，如果你们还记得在课堂上，我们讨论了一点吞吐量，呃，它允许我们平均每秒发出多个指令。

以最大的效率和结束级管道作为管道中的指令，所以我们可以用这种方式级联这些指令的想法，我们在任何给定的时间使用管道的每个阶段，但是，如果你去听讲座，你所看到的一切都变得有点混乱，嗯。

某些指令可能依赖于由其他指令设置的值和寄存器，不同类型的冲突给我们带来了危险，我们一会儿再谈，但就管道数据路径而言，在我们开始之前，大家还有什么问题吗？所以是的，所以我们要有这五个阶段，我们接到指令。

指令解码，执行内存并写回，嗯等，这是在你工作表的背面，但这本质上是我们将要使用的数据路径，有时候如果你看看过去的学期，你会注意到，像mgen这样的东西实际上会执行，与指令解码，但是嗯。

你总是被赋予一个数据路径来引用要处理的东西，但是嗯，正如我们在介绍数据路径时所说的，有一些组件在并行工作，指令解码中的通知，我们有重新归档和即时生成器并行，嗯，更深层次的话题，我们稍后会讲到。

这里的分支比较器实际上与alu并行，有人知道为什么，是这样的，是啊，是啊，呃，分支比较器将接受寄存器文件中的寄存器值，它将决定它们是否小于1，比另一个少，或者他们是平等的。

然后它会向控制单元发送两个控制信号，那口井，我是说，这是很好的考虑到所有ALU的一部分正在检查这种情况，不完全是这样，它与ALU是分开的，它会做一种，像算术一样，一种评估权，它将检查一个是否大于另一个。

嗯，但事实并非如此，它和外星人是分开的，但有人知道为什么这和ALU是平行的吗，从球棒上看是有点棘手的，如果我们使用分支指令，这是我们真正使用分支比较器的唯一情况，我们实际上对分支比较器提供的东西感兴趣。

嗯，那样的话，对于分支指令，我们的B细胞和A细胞总是一个，这意味着我们的程序计数器会自动地，我们有我们的即时发电机自动进入ALU，所以当我们弄清楚我们是否要拿走树枝的时候，我们已经有了，如果你真的喜欢。

从ALU出来，嗯，这些值是这些值被发送到这个多路复用器就在这里，所以我们要采取一些，或等于或大于将其发送到控制逻辑，那么在下一阶段，嗯，甚至在右后阶段，我们的控制单元将决定我们是否要把电脑。

加四或这里的ALU输出，所以本质上我们在做分支比较，分支比较，同时我们的ALU在这个阶段工作，这是一个，我希望我没有因此失去你，但是输了，所以说，那真的很重要，当我们想知道在这些阶段中最长的路径，就是。

嗯，我们需要考虑哪些组件在并行工作，哪些组件比其他组件慢，所以说，继续走，哎呦，也在这张幻灯片的底部，这是一个很重要的笔记，所以一个非流水线的时钟周期，依赖于整个数据路径的关键路径，对呀。

所以在非流水线时钟周期中，我们这里没有这些登记表，我们基本上只有这个PC寄存器，所以数据路径，或者关键路径是从这个寄存器的时钟到q，贯穿数据路径的组合逻辑，然后这个的设置时间，然而现在当我们把它输送到。

我们要把它分成几段，我们要说，我们CPU的关键路径真的取决于，其中任何一个阶段之间的最长延迟，任何有意义的阶段中最长的关键路径，是啊，是啊，我的名字更像是，嗯，是啊，是啊，是啊，是啊。

所以本质上我们有一个很大很复杂的电路，然后呢，流水线基本上可以让我们把复杂的电路，把它撕成碎片，因此，你知道的，如果我们做一个，嗯，就像一个非管道，呃，CPU，嗯，我们的指令将通过IMM。

可能会通过注册文件，嗯，穿过阿鲁河，但是看看如果我们在指令上得到U，这里所有的东西都是闲置的，所有这些东西，所以它允许我们更多地利用我们的CPU，反过来，我们可以每秒输出更多的指令，CG。

所以直接进入第三个问题，我给你一点时间，他们已经给你安排好了，所以我想是上周我们在设置上遇到了这个问题，还是在那之前的一周，呃，上面的SDS是上周的，那是上周，好啦，是啊，是啊。

所以上周我们决定最长的教学，或者关键路径是基于给定延迟的加载字指令，这个问题给了我们，嗯所以知道，试着找出最快的时钟，给你一点时间，我会把这个带回来，其实呢，让我们看看我能不能把这个复制过来。

如果您面前没有数据路径。

我真的需要这份工作，所以想想加载单词指令，考虑load word指令需要哪些组件，我们一会儿就回来，好啦，所以希望我们都有机会开始，嗯，所以让我们追踪加载字指令的路径，所以首先，管道中任何指令的开始。

我想从这里开始，个人电脑是的，PC的输出，是呀，所以我们就在这里，嗯所以呃，每一条指令都进入到项目中，我们需要从记忆中获得指令，所以马上，我们有，见，时钟到Q，嗯，我们从他们后面读出了记忆，所以说。

我的空间快用完了，我就写，所以我们要到这里来，而且我认为这个问题是假设，嗯，是啊，是啊，单周期数据路径，所以我们不是在管道方面工作，对不起，我们开始之前我没说清楚，不过，好吧，所以是的，是啊，是啊。

是啊，是啊，所以问题是说一个单一周期的数据路径，意味着一个时钟周期对应于正在处理的整个数据路径，所以我们这里不是在讨论管道数据路径，对不起，我应该在我们开始之前澄清的，但是嗯，是啊，是啊。

所以我们现在要忽略的所有这些管道寄存器，好啦，所有这些蓝色寄存器，我们假设我们有规则的单周期数据路径，好啦，所以向前看，从IMM出来，我们已经阅读了我们的指示，我们正在通过。

所以现在我们有两个平行的单元，我们有注册文件和即时生成器，我们对哪一个感兴趣，我们所看到的关键路径，所以说，我们要在计算中加入什么，媒体生成器好吧，所以我们有两个平行的组件，我们有15皮秒的延迟。

或重新文件读取，也就是一百皮秒，所以我们要选择最长的延迟，因为我们感兴趣的是最长的组合延迟，所以我们要添加我们的reg文件read，每个人都有道理，好啦，所以从注册文件中出来，我们对什么感兴趣。

穆克人是对的，因为我们不使用分支比较器，这只是一个加载字指令对吧，好啦，所以让我们在这里添加我们的多路复用器，通过多路复用器，我们直接进入ALU，这里没有别的路可走，对呀，是啊，是啊。

即使你用俄罗斯选手，你说它发生在ALU的一部分，然后这将归结为这样一个事实，如果ALU大于如果ALU，总比树枝回来好，然后你仍然不会用一堆确切的，谢谢你提起这件事，我们一会儿就会讨论这个问题。

还有另一个问题，但你百分之百，对嗯，如果我们有兴趣，就说这是一个分支指令，我们将权衡分支比较器是否比ALU花费更长的时间，是啊，是啊，完全正确，但是，是啊，是啊，所以我们将直接进入ALU。

我们能准确地确定ALU在这里对加载字做什么吗，我们为什么要用ALU，添加，是啊，是啊，立即在媒体上添加什么，是啊，是啊，是啊，是啊，所以我们加载了某种内存地址的偏移量，对呀，这个加载词接受了一个即时的。

这是我们给它的地址的偏移量，嗯，所以我们需要计算偏移地址，所以我们通过ALU，从阿鲁出来，我们直接进入DM，我们在这里用DM吗，是啊，是啊，这是一个加载词，所以我们必须进入主内存，所以我们要再读一次。

Amux，是啊，是啊，是的，是的，所以我们走出这个门，在这里直接将数据读入这个多路复用器，这个月之后还有什么事吗？所以我们读取了我们的记忆或从记忆中读取数据，现在通过这个多路复用器。

数据路径带我们去哪里，关于我们在做什么在加载词，加载字指令的最后一步是什么，是啊，是啊，回到我们的登记簿上，是啊，是啊，完全正确是的，所以我们要把从记忆中读到的数据，让我一路往回走，在我们的右边。

我们要把数据写回寄存器，所以这就增加了，哦耶，在这里重新设置，所以说，所以因为，我们的数据路径在这里结束于reg文件，它是一种注册权，这就是我们的设置时间，否则，我们通常有一组其他寄存器的时间。

但是是的，哎呦，你需要阅读的时间点在哪里，所以我们忽略了直接发生器，你知道为什么，因此即时生成器与reg文件并行，对呀，所以我们的指令分成了两条不同的路径，然后它们最终会聚在一起，嗯，因此。

既然我们试图计算数据路径的最长延迟，我们想，真的吗，是啊，是啊，我在这里没有说清楚，但这个，这里是reg文件之间的最大值，读或读，嗯，这就是为什么我们要带着区域数据一数据二下去，我将使用一个寄存器。

然后立即添加到，呃，是啊，是啊，有道理嗯，这里有一个微妙之处，所以说，事实上，每条指令几乎都要分支，但是，到达reg文件的控制信号将告诉reg文件，哪些是真正应该关心的，是啊，是啊，我想是的，我猜。

如果我们要用，就像两个寄存器都不可能比这更快，等着，是啊，是啊，我不认为，有一个实例，我们不会读取任何寄存器值，对于我们在这门课上所学到的任何指令来说，有没有一种情况我们不需要从寄存器中读取任何值。

我不这么认为，是啊，是啊，我不这么认为不，你总是要去读，是啊，是啊，所以是的，所以说，不管我们是什么，我们至少要从一个寄存器中读取一个值，也许两个好问题，在靠近电脑的左上角有什么标记。

下一步的聚会是什么，因为对于某些指令，PC本身必须取出，嗯，是啊，是啊，是啊，是啊，完全正确是的，所以这是一个加载单词指令，对呀，所以我们正在加载来自dm的内存，我们需要写回reg文件。

但同时我们也在计划中增加了四个，但是，我们在这里的关键道路并不依赖于那么多的权利，因为我们的数据路径在这里直接结束于重新文件，所以我们基本上有了一个关键路径的布局，在这里我们有所有的延误。

所以我们可以把这些加起来，我们的时钟延迟了30秒，我们有一个记忆读数，也就是，是一百个我们有一个多路复用器，也就是二十五，另一个内存读取，一共250块，我们还有一个杯子，也就是两块五。

然后Reg文件安装时间只有20微微秒，所以这最终，如果你把所有东西加起来，它最终是900皮秒，我们整个数据路径的关键路径，如果我们不是皮佩尔，好啦，但本节的全部目的是开始研究流水线，所以说，让我们。

让我们考虑管道数据路径的最快时钟时间，有人想提醒我，管道数据路径的关键路径到底是什么，我刚刚才说过，这是两个寄存器之间最长的时间，是啊，是啊，任意两个管道寄存器之间的最长延迟。

所以基本上我们这里最长的舞台，所以让我把这些处理掉，给你一分钟想想哪个阶段会是我们这里最长的，现在呢，把延误留在这里，我也想对你的电脑加4发表一点意见，因为你确实提出了一个很好的观点。

我想让大家明白当我们开始教学时，我们从这里开始，所以我们也有另一条平行的路径，我们穿过这里或这里，因为我们对最长的平行路径感兴趣，我们真的不认为这台顶级个人电脑加四台，好啦。

所以当我们开始考虑管道数据路径时，让我们把它分成五个阶段，我们的指令提取阶段包括，注意每一个阶段，所以我就写下来，每个阶段都有一个开始和结束的寄存器，所以每个阶段的每个关键路径都有Q延迟的时钟。

和安装时间，所以暂时忽略这两个延迟，嗯，我们在指示中处理的是什么样的延误，去拿，记忆是的，正是这样，我们在那里有IMM组件，所以说，这就是我们除了开始的PC寄存器之外的所有东西，和结束管道寄存器。

我们所拥有的只是那个阶段的IMM组件，但我们也不一定是真的，呃，我们也有这台PC加四台，我们刚刚谈到了多路复用器，但是我们的记忆读数会比我们的多路复用器长，我们这里有一些组件，我们对哪个组件感兴趣。

这会给我们最长的延迟，是啊，是啊，害怕的正是，所以我们有直接发生器，嗯，我们要处理的是，此阶段中的reg文件设置，或者只有三个，只是为了阅读，是啊，是啊，呃，reg文件设置，如果你还记得就在后台，它。

看起来是在这个阶段，但真的，它位于这个多路复用器之后，是右后卫的数据路径的末尾，所以让我们把指令写下来，解码，我们有我们的文件读取，接下来是执行阶段。

谈了一下这个，在这里，延迟是最重要的，它是多路复用加上Lu吗，是啊，说得好，呃，呃，包括那里的多路复用器，注意我们有两条平行的路径，我们有分支比较器，或者穿过淤泥，穿过阿鲁河。

所以两者之间的最大值是MUX加ALU，接下来是MEM舞台，我也会把我们延误的时间调出来。

这是我们在MEM阶段最长的延迟，我想我们可以从列出，比如MEM阶段有什么延迟，我们的记忆对吗，哦耶，去吧，只是内存读取，是啊，是啊，好啦，因为呃，就像注册文件一样，红色的右边。

这里的MEM也与右后台相关联，否，我错了，对不起，那不一定正确，嗯，但是是的，记忆是，记忆写二百，读二百五十，我们有什么，不要。

那么我们就在后台了，一切，在这些管道寄存器之后，这是我们在这里耽搁最久的时间了，是啊，是啊，标记加上右边和注册右边，所以我骗了你，因为呃，我们包括了设置时间和关键的，或者排队等待所有这些阶段的时钟。

对呀，嗯，你是对的，注册表文件，设置时间，下面是与之相关的延迟，但这也是数据传递的结束，所以所有这些阶段都包括一个设置时间，所以除了排队的时钟之外，唯一的延迟，设置是马克杯，这里。

对每个人来说都有意义吗，这是一个微妙的点，但是，我们不会有另一个设置时间后，山脊，对呀，本质上，所以我们这里有一个多路复用器，所以看看我们的延误，你认为哪个阶段会决定我们的关键道路，抓住他们，是啊。

是啊，完全正确，但是，正如你所看到的，内存是所有这些组件中最长的延迟，但是是的，我是说一切加上在设置中排队的时钟，这意味着总共延迟了30分钟，加，然后记忆是250，所以我们的关键路径是300皮秒的延迟。

这是我们的时钟所能达到的最快速度，是啊，是啊，嗯嗯，如果max+alu是大的呢，呃，记忆，在执行阶段，啊，啊，你的意思是，喜欢喜欢什么，如果这个阶段比内存读取的时间长，是啊，是啊，是啊，是啊。

所以在这种情况下，嗯，假设它也比这里读取的内存长，是的，这就是我们的电路的关键路径，是啊，是啊，那将是我们最长的舞台，有时是的，到目前为止，大家对此有何感想，有很多值得看的，但是，所以我们要继续。

所以我们基本上是在流水线化数据路径后，请注意，我们已经从900皮秒增加到了300皮秒，这是呃，将计算一条指令所需的时间缩短三，挺好的，那么为什么不把速度提高五倍呢，好了，我们把我们的数据路径。

把它切成五块，为什么不是，是啊，是啊，因为我们不会分成五个人，在我们的销售中给一些危险的人提供动力，完全正确是的，所以有些阶段可能会包括，可能是整个电路延迟的40倍或40%，所以当我们把它分开的时候。

那个阶段将决定整个赛道的一切，但是是的，所以说，我觉得这就足够了，对此有什么问题吗，所以让我们来谈谈危险，嗯，我们有三种主要的危险，这里有结构危险，本质上是两个指令试图在我们的电路中使用相同的组件。

同时我们也有数据危险，假设你有一条指令，它将设置寄存器的值，接下来的指令需要读取寄存器中的值，也许第一个指令还没有说出来，第二个正在读，是数据危害，然后我们有控制危险，嗯，与分支和跳跃有关。

基本上我们不会决定我们是否要采取一个分支，直到我们的指令执行到一半，所以我们不知道我们是否需要执行，以下指令或某些指令15行以下，那么我们在分支之后将哪一个排队进入数据路径，关于这三种危害的问题。

所以我首先要注意的是，风险五，基本上处理风险五架构基本上为我们处理结构风险，所以我们这里的电路，所以一条指令可能在后台，当我们的reg文件在不同的指令中从寄存器读取时，风险五架构在这个DM阶段分裂。

在这个IMM阶段，往那边走，我们有两个相互分离的内存访问，所以我们可以在一个阶段从内存中读取指令，然后在另一个阶段从内存中读取数据，所以我们从来没有真正遇到过需要，或者需要两个指令中的相同组件。

说我们没有那些东西，以下是一些后续的解决方案，我们可以轮流，使用资源，利用摊位，或者不是实际上，就像x零是你的整个指令，只是被忽视了，或者我们只是增加更多的硬件，就像我们在风险五号为我们做的那样。

我们只是添加了另一个组件，允许我们从内存中读取，所以最重要的是，我们有数据危险，所以考虑一下，例如，我们把直接的5加到t 0，是啊，是啊，这是上一张幻灯片，是啊，是啊，当你说软件解决方案时，比如使用。

就像我和法律为教练的危险，我是说我宁愿插入，在两条指令之间的是汇编程序，我想装配工会处理不，不不不，它将是编译器，你说的对，是啊，是啊，是啊，嗯，但就像它是一个火，是这个吗，这是什么意思，我实际上。

你知道的，就像你那个，程序正在运行，是呀，我是说，是啊，是啊，所以假设你的编译器和你的机器一起工作，因为我的意思是有很多编译器，是的，还有许多不同类型的计算机架构，你不想做，就像解散，像编译器被告。

或者像哈佛的被告，你可能会出现在搜索中，就像什么，部门有，那是个有趣的问题，所以基本上你会有硬件手柄结或延迟，有可能，是啊，是啊，你可以添加额外的控制信号，我想，是啊，是啊，是啊，是啊。

所以我们同时也有一个读-写-D图，所以我们我不知道，不不我们，我们不能同时读和写，因为这是一个阶段，对呀，这一个部件，所以这将是一个结构性的危险，所以有很多方法，就像阅读和写作来记忆。

这就是我们现在在数据转发方面所面临的问题，嗯，我们可以从那里开始，本质上，是啊，是啊，与内存有关的数据危险，说，在这种情况下，我们有加载词指令，我们要取一些地址，读取那里的内存并将其存储为T零，呃。

我的意思是，如果如果呃，如果寄存器使用不同的，呃，类似的内存地址，呃，有些寄存器可能需要一些其他地址，然后同时另一个寄存器读或写，呃，另一个地址，对不起，我不太明白，呃，就像呃，所以我们为我安排了。

所以说，在这种情况下，我们总是用为零，但如果有一个登记簿，也读写为零，作为一个整体，对呀，所以你是说在这里，我们会有另一个负荷词，那是，呃，就像一个零和一个像另一个加载词，或者像广告一样，好啦。

所以会怎么说呢，一零为一，记住这些会像这样层叠，所以当我们在这个阶段使用存储单元时，对所以我们，呃，在这个地址从记忆中读取，在下面的指令中，这个加载词就在这里，我们将执行即时偏移。

然后接下来的时钟滴答作响，我们将根据记忆读取，你看，所以它们不是同时发生的，他们就像一个接一个的时钟滴答作响，这有道理吗，就像，如果我们回到，一个加载词就在上面，下一个加载词就在这里。

所以这个加载字使用的是dm，就在这里，它会同时读取数据，另一条加载字指令将计算内存地址的零偏移量，所以在下一个时钟滴答作响的时候，我们正在写回我们在第一个加载字中读到的数据，同时。

因为这个加载字正在从内存中读取，所以它们实际上不会碰撞，但他们很亲密，好啦，清除，好啦，所以说，基本上，在这里，我们有这样的情况，这个指令是在这个加载字之后出现的，但它依赖于从t零读一个值。

当我们在t零处读到这个值时，哪个阶段有人知道，指令解码正确，所以当我们从reg文件中读取时，所以在这个指令中解码，我们需要价值，t零的更新值，但是，就在那个时候，这个加载字只计算偏移量。

它还没有更新这个T零，所以现在这个指令使用的是旧版本的t 0，所以数据转发说的很好，如果我们把记忆组件，所以当我们把这个偏移量的内存读为零时，让我们立即把数据发回那边，当add正在执行阶段时。

它只是短路在那里执行，这变得很复杂，因为有很多不同的地方我们可能需要转发内存，这增加了更多的控制信号，但它确实解决了这样一种情况，即你知道我们可以快速地获得下一条指令的信息，高层。

这对每个人来说都有意义吗，我们就这么加一根电线感觉不对，但是当你考虑设计一个CPU时，这些都是需要考虑的事情，基本上它的作用是，它使我们不必在这些指令之间放一个旋钮。

因为加上一个nop只会让我们的指令延迟另一个时钟滴答声，就像那个数据危险，我们有另一个数据危险，我们有简单的，比如添加说明，一些简单的算术指令，在这种情况下，呃，假设我们写的是5到t 0。

但是这个shift指令需要t为0的值，然后也更新T零，基本上我们不能等到写后台，在我们开始阅读之前，我们迫不及待地等着它写回寄存器，是另一种情况，我们要执行零加五，直接从ALU。

我们要把它送回ALU的开头，这样，当shift指令接收它的红色值t-0时，或者这个短路值t零，它就会直接进入路，然后移动两个，我们会没事的，说是的，好像是，你怎么知道什么是允许的，就像。

允许链接到的内容，因为这似乎是一种随机性，现在呢，你有什么具体的指导方针要遵循我们吗，哎呦，你不能这样做，原来你是，听起来好像，你有点像在思考这些想法可能带来的问题，对呀，是啊，是啊，嗯，你说得有道理。

我想在这里要意识到的主要事情是，当我们可以使用转发通知，呃，我是说，转发字面上有转发这个词，对吧，我们不能回到过去，但我们可以说你知道，我们计算了实际的t零值并执行，这条指令过去没有执行过。

当您真正喜欢需要该值的最新可能时刻时执行，因为你要用它来计算，因为那是在这个阶段之后，我们可以把它向前发送，记住，这些是同时在时间上，所以每一个时钟滴答声都对应于这些并行的过程，所以说，嗯其实。

我们快没时间了，不过，我得先看一下，所以说，我们将研究这个问题，所以我们这里有这些说明，嗯，这是我们时间的级联，有人看到这里有危险吗，哪些指令是危险的，坏眼睛和T零会准备好爱它吗，所以不会对，嗯。

如果我们看一下，我们有这个加i指令，它实际上不会更新T零，直到右后台右，它又回到了收银机上，但与此同时，这个加载字已经从某个t零地址的内存中读取，那是一个旧的t 0，所以这确实是个问题，还有别的事吗。

是啊，是啊，然后后面的add指令，是啊，是啊，所以这条指令将把一些数据加载到t 1中，但是这个指令需要读取，所以这是另一个危险，所以我们有两件事要做，然而，第一个让我们来看看这个嗯。

我们能用数据转发来解决这个问题吗，就像我们刚才看到的，在添加i指令中最快的时刻是什么时候，我们有必要的价值，执行，是啊，是啊，完全正确是的，所以我们要在之前零点的基础上再加四个，所以让我们我就这么做。

所以这是最快的，最近可能的时刻是什么，对于加载字，我们需要该值为零，因为你需要知道地址并加上偏移量，所以因为这是在时间上前进，我们可以使用数据转发，所以这就像我们之前说的，我们有我们的。

我想这就是ALU的样子，但基本上我们只有这个循环，它可以追溯到，然后我们的渣滓将决定，我们的控制信号将决定我们是否真的走这条路，好啦，但让我们快速看看另一个危险，因为这很重要。

我们能用数据转发来解决这个问题吗，否，为什么我们能做和以前一样的分析，什么是，我们能在什么时候得到这批货物的价值，字，记忆权，所以我们读取数据，它从我们的恶魔那里输出，但我们最快什么时候需要它呢？

还是对不起，我们广告指导所需的最新时刻，执行是，我们的ALU需要它，但这两件事同时发生，所以解决这个问题的唯一方法就是知道我们现在所知道的，才是我们真正需要的，就像这个时机，我们就这样算了。

我们可以使用数据转发，从这段记忆中，所以我们需要一个，我们得把下一个地址推迟一小时，对如果这些是时钟滴答声，我们再推迟一个小时，我们可以使用数据转发来解决数据危险，好啦，关于那个话题，这是一个。

这是一件复杂的事情，但这确实是数据转发最复杂的部分，所以指令是用t 0而不是t 1，然后你可以伪造到4只是为了确认，嗯，所以如果我们需要T 0的更新值，对呀，所以正确的后台发生在指令解码的同时。

当我们从reg文件中读取该值时，所以我们仍然需要数据转发，对呀，我们有合适的后台，所以我们必须把数据从，嗯，我是说，我们甚至可以从右到右写它来执行，中间有两条指令，那就没问题了，因为正确的后台会发生在。

嗯，这个指令解码，是呀，没问题，嗯，在你走之前我们的反馈表，我真的很感激。

P32：Lecture 24： Caches - Direct Mapped I - 这样好__ - BV1s7421T7XR

是啊，是啊，喔喔，喔喔，期中考试结束了，谢谢你的耐心，当他们想出如何给你们所有人发布成绩时，处理所有发生的紧急情况，我们知道这是一个超长的期中考试，但是我们从学生那里得到的反馈是非常积极的，话虽如此。

你们也是学生，如果不是超级积极，我们也在想办法，有几个，在我们开始之前宣布另一个消息，这是一个民事订婚公告，你们中有多少人在加州登记投票，好啦，百分之五十的人，你们中有多少人计划在加州登记投票。

并有资格，好啦，好的好的，所以提醒一下你必须在周一前注册，往那边走，你可以在选票中收到邮件，如果你之前没有注册，星期一，你必须亲自去，选票退出，所以我想提醒你，所有选举日都是11月8日星期二。

好厉害好厉害，好啦，所以今天我们有一位很棒的客座讲师，你可能已经认识她了，她叫卡罗琳，她是我们的一员，我们的摇滚明星，或者61 c，这是一种方法，即使我今天在这里，这是我和丹的一种方式。

培养下一批伟大的讲师和导师，我们可以在，伯克利和世界各地的其他CS机构，废话不多说，卡罗琳今天要介绍缓存，让我们为卡罗琳热烈鼓掌，我先把它固定好，所以我可以用我的手测试，音频在线怎么样，就像这样，是啊。

是啊，所以我们今天的课，目前在打印它们方面遇到了困难，他可能会在某个时候带着咖啡出现，但我想我们也在想办法把这些推广到网上，在此期间，是啊，是啊，他们总有一天会好起来的，对不起，嗯，但是是的，真的很快。

就像上次的一个简短回顾，我知道我们可能没有机会，就像上一堂课完全没问题，缓存并不依赖于此，但我还是建议你有机会回去看看，上次我们谈到，在数据路径上展开，如何将我们正在进行的不同硬件部分并行化。

又名如果你看的话，它被称为流水线，所以一般的想法是在不同的阶段之间插入寄存器，有线组件，基本上是沿着不同阶段的时间值，在整个过程中，我们还意识到内存访问仍然非常慢，即使我们可以并行不悖。

所以我们想试着减轻这种情况，所以还有别的事，作为一个简短的提醒，流水线使数据依赖关系以危险的形式非常明显，所以我们讨论了三个主要的，如果这些术语对你来说真的很陌生，没关系，这堂课并不依赖于此。

然后一般的想法是好的，我们通过添加不同的硬件和不同的逻辑单元来解决这些问题，所以我们也试图修复这个想法的方法之一是，好啦，嗯，如果记忆真的很慢，为什么不投入更多的硬件，这就是我们在这节课里要探讨的。

嗯是的，也很抱歉，我今天视力有点差，所以如果你有问题，请随意，只是举起你的手，稍微挥舞一下，所以我们今天的议程是我们要讨论的，一些二进制前缀，我们要谈谈，回到，当我们谈到在不同的值前缀时，如何嗯。

我们可以看看数量级，我们还将回到嗯，可能是第二课，当我们谈到内存层次结构时，所以我们要再复习一遍，然后我们将直接进入缓存，所以二进制二进制前缀，做，这些前缀对任何人来说都很熟悉，好啦，如此熟悉，嗯。

我们可能已经被介绍给它在我们的整个，像中学时代，也许小学，也许是高中，所以如果是小学的事，嗯但是是的，这些都是很常见的前缀，它们也叫si，法语中国际单位制的意思，也就是我们已经用了一段时间的东西。

现在呢，另一个关键部分是它们都在十进制，所以就像10到第三个10到第六个10，十到N，这对我们的标准用户和公制来说真的很好，但它提出了一个小问题，我们一点一点地工作，在CS和硬件方面，就像，为什么不呢。

为什么我们的同类单位不与之对齐，是啊，是啊，所以当涉及到比特时，十进制是很难处理的，所以我们说，好啦，嗯，为什么我们没有二垒的东西，所以我们叫它别的，我们不知道那是什么，现在还有别的事。

所以你可能听说过，啊，是啊，是啊，我的电脑有一千字节，不是千字节，假设有千兆字节的存储空间，或者1TB的存储空间，然后你可能会进入你的系统硬件并查看它，就像等待，为什么上面写着，如果我有九十九万四千。

像这样的东西，好像不匹配，原因是这两个单元之间有某种差异，以及CS的不同部分很好地使用它们，我们还没有完全同意使用一个完整的系统，所以硬盘制造商和电信网络，善良的人，他们真的很喜欢用SI因子。

所以他们真的很喜欢根据标准使用这个，所以就像广告上说的那样，硬盘驱动器实际上容纳了你实际期望的90%，所以你实际期待的通常是，就像基础二领域的东西，但实际上他们提供的是基本时态，那么为什么这很重要呢。

如果我们从两边往前，我们可以看到这是两者的比较，嗯，基本单位种类，所以在右手边，嗯，如果我用鼠标，是呀，我们可以看到在右手边，我们可以看到SI的大小，所以我们看到10到3，代表公斤，大约有一千。

然后我们在这里有一个相应的类似的基数2因子，那是十分之二，大约是一千，但略高于这两个，四个字节没什么大不了的，那么如果我们去一兆字节的，所以说，我们有十到六，它大约有一百万字节，或者这就是我们所期待的。

或者这就是我们在那里看到的，如果我们看到这里的因子，呃，二到二十，所以二乘二乘以十，我们得到的比这稍微多一点，所以我们得到了40，八千，576个额外字节或额外字节，然后当我们往下走的时候。

我们看到我们得到的偏移量变得更大，所以两者的差别越来越大，这种差异反映在百分比上，如果我们仔细想想，如果我们回到之前的幻灯片，它会让我这么做的，和像之间的切换，我的老鼠呢，哦，我们走吧，好啦。

所以如果我们在硬盘里的这两者之间，我们实际上有10到12个字节，所以在硬盘世界中，1TB是10的12，但在操作系统方面它说，好啦，嗯，我想用二次方来表示事物，但我们可以从前面的图表中看到。

如果我们有10到12，它将内在地期望支持更多的字节，比我们实际，比我们实际拥有的，所以取而代之的是，我说，好啦，基数2和基数2是什么，这将是我们以前的90%左右，然后在网络方面，如果你看到像一兆比特。

一种交流，这不是真的在谈论它，就喜欢而言，哦，两个到嗯，两个到20，这将是像，好啦，我实际上只有10到6，所以这种差异并没有太大的区别，当你工作的时候，你不会注意到的，但当我们以后计算时。

这就有了很大的不同，因为这会让你的生活轻松很多，当你用二进制做事情，用比十进制更好的位时，比如，如果有人让你取10到6的平方根，或者像这样的基础两个，我不知道，我不知道你们怎么想，但我需要一个计算器。

嗯有什么问题吗，所以介绍一下，然后这些前缀，而不是被称为SI前缀，我们称他们为I，它代表，让我们看看国际电工委员会，回到1999年，这可能是我们这里一些人的出生年，也许90年代的婴儿。

它引入这些基本上是为了指定二进制量，所以我们可以看到它们和我们的SI非常相似，嗯速记，除了我们通常在末尾加上一个i，所以你把它念成，基本上就像Kib字节，也许字节，咬伤等，听起来有点傻，但这是我们用的。

所以现在如果我们提到像KB这样的东西，我们几乎总是指十进制的数量，如果我们把某物称为k ib，那么我们是特指它，在基数2中，有道理，一般的上升点头，好的太棒了，所以丹有一大堆助记符来记住这些。

如果你喜欢助记符，从这些中挑一个，或者只是为了好玩，想出自己的，但就我个人而言，我发现最容易记住的是，这些只是为了知道它们基本上对应于它们的si前缀，你通常不会被要求真正记住，或者能够计算出任何东西。

可能在这上面，所以你可以就像啊，奇怪的前男友，那将是最大的，我真的得记住，但是是的，所以现在我要继续前进，为什么我们一开始就需要这个，我们为什么要关心这口井，嗯，我们在后面的数据路径部分查看了这种图。

我们在课程开始的时候看了它，当我们有一个总的概述，所以这只是一般地映射计算机的组件，所以我们从左手边的处理器，我们走到这里我们在左手边有处理器，所以我们可以看到，通常有控制逻辑，我们有我们的数据路径。

那是一个可爱的盒子，我们有我们的档案和我们的登记簿就在这里，然后我们有我们的ALU在这里，所以这只是我们数据路径的一般思想，芯片上有什么，所以我们注意到有一种存储形式。

实际上是在芯片上或与处理器在同一种硬件上，这就是寄存器，那些存储值，但我们对寄存器的了解是，它们的数量非常有限，而且尺寸也非常有限，所以我们不能只拥有某种记忆，主存储器，是一个巨大的寄存器阵列。

所以取而代之的是我们这里的片外存储器，所以这就是我们所说的，啊，这是我们的主要记忆，所以我们这里有很多字节，会很漂亮的，非常非常大所以在两者之间，好啦，我们的处理器有时会写入内存。

它会提供一个地址来做到这一点，然后在两者之间，我们的接口基本上能够写入数据并从中读取数据，把东西搬来搬去，所以把东西带到登记处，然后将寄存器中的东西交换回主存，所以这就是我们的处理器内存接口。

你不需要真的记住那个术语，但这是一种控制器系统，一种能够进行这项工作的逻辑，现在在我们的另一边，我们有我们的输入和输出，我们将更多地讨论这个问题，在后来的讲座中，你可能听说过I O的想法。

所以这只是我们与外部世界交流的方式，所以说，又名，如何把东西带进来的系统里没有什么，然后把东西送出去，就像，例如，你的键盘就像你在发送信息一样，然后你的屏幕输出信息，这就是我们的i o内存接口。

我们会在很多很多节课上更多地讨论这个问题，所以整个问题就像，嗯，我们知道大内存是慢的，就像我们知道主存没问题一样，它比磁盘好，但也不是那么好，就像在时钟周期的尺度上。

我们的寄存器可能需要一个时钟周期才能访问，但是主存可能需要100个时钟周期，而我们的磁盘有一万个以上的时钟周期，所以一百块比一万块好多了，但还是没那么好，如果我们只能等这些手术，所以如果我们回想一下。

很久以前当我们谈到图书馆的类比时，为什么它实际上这么慢，如果我们在考虑它储存了什么，假设我们用图书馆的书写报告，我知道谁从图书馆借书，什么嗯，所以说你想让德萨林格丹喜欢他的经典作品，嗯。

所以我目前在当前的记忆状态是有点像好的，如果我有内存地址，我知道我想要什么，我们去图书馆，我们访问内存，然后我们穿过图书馆，穿过书架，说，好啦，现在这个架子没有我想要的东西，让我们去下一个。

这个架子上没有我想要的东西，你继续这样做，直到你找到那本书，或者你可以问图书管理员，但是我们没有图书馆员和主存，所以现在我们有了我们的书，然后我们从里面访问我们需要的任何数据，一旦我们完成了这本书。

我们把它放回去，但我们也许可以记住那本书在哪里，所以也许第二次你需要像捕捉骑行或其他什么，你可以直接去那个地方把书挑出来，所以如果我们需要在那个大图书馆里找一本书，好吧。

有时间我们需要实际目录东西在哪里，我们需要仔细检查并实际搜索，我们需要去喜欢，字面意思是步行去图书馆或公共汽车去图书馆并访问它，然后我们需要去身体上，去图书馆找那些东西，所以要花很多时间。

所以图书馆越大，通常越大，延误越严重，所以如果我们说像伯克利，我们有很大的伯克利公共图书馆，但不是那么大的权利，所以去那里不会花那么长时间，然后当你在搜索，可能需要几个小时，我们会说。

但这不是世界上最糟糕的事情，现在想象一下，如果你去纽约市公共图书馆，我不知道这是不是一件事，但就像，想象一下它要大十倍，可能就像在市中心，你可能不住在那里，所以到那里要花更长的时间，当你经历的时候。

你面对的是过道和过道的架子，然后可能要花一整天才能找到你需要的东西，所以如果我们把它带回主内存，那么这种数据结构越大，或者不是数据结构，存储东西所需的硬件结构，找到所说的东西需要的时间就越长。

所以有点看穿，呃，延迟间隙，我非常呃，无耻地从舞蹈幻灯片上偷了这个，但这是对事情进展的一个很好的解释，所以我们可以看到从1980年一直到2010年，这绝对是现代的，呃。

我们可以看到处理器的速度真的真的大幅提高了，所以我们看到有一个相当指数的增长和线性的，然后我们现在逐渐减少它，但是如果我们看看我们的内存访问延迟，我们可以看到这是一个非常非常缓慢的线性增长。

所以如果我们的处理器现在真的真的很快，我们说好吧，我经常需要访问内存，我需要你尽快，记忆将无法响应，他们就像举起，等一下等一下，你需要等到我做完之前，你实际上可以访问，所以我们这里有一个很大的差距。

这并不真正有效，那么那口井的解决办法是什么呢？我们要回到内存层次结构的东西，所以这个想法就像我们说的，如果你需要你，你有一本书，你很有可能会再次使用它，除非它可能像一个报告，你讨厌这本书。

但你知道我们不这么想，如果你还需要一本书，然后你去图书馆借一本新的，不过，那本书你可以帮我们保管，在你尝试退货前两个星期吧，但是你不退你以前已经退房的东西，所以希望这能让你收藏一些书。

这对任何报告都很有用，或者你将要做的任何有趣的事情，所以它使你不必在我的记忆中旅行，每次你需要的每一条信息。

那么我们就有了，我们看一下这样的东西，所以我们从CPU开始，嗯，然后我们有我们的寄存器，我们有我们的登记簿在这里，然后我们在这里有我们的物理记忆，然后我们有什么，嗯，在中间进行，但这里有个缺口。

那么我们到底要坚持什么来弥合差距呢，有什么想法吗，缓存，是啊，是啊，我知道很震惊，对嗯，正如这节课的标题所暗示的，我们把隐藏处放在那里，所以缓存的一般概念只是在，或者是两个不同点之间类似存储的中间形式。

所以就内存存储而言，我们的处理器所需的，然后我们实际的记忆速度是多少，所以我们增加了一个新的级别，称为内存缓存，所以实现明智，这是用一般的，我看还是集成电路设计作为CPU，所以后来。

我们将探索不同类型缓存的想法，实现可能喜欢什么，影响访问所需的时间，但我们只考虑缓存的一般情况，现在将以类似于处理器本身的方式在硬件中实现，因此，这有助于非常快速和非常好的快速访问。

但这也意味着它可能相当昂贵，这不是你必须记住的东西，但我们可能指的是SRAM这个术语，DRAM，嗯在剩下的时间里，我想那些隐藏处和讲座，所以SRAM就是同样的想法，但它是静态随机存取存储器。

DRAM代表动态随机存取存储器，你真的不知道，你需要知道两者的区别，只是SRAM通常更贵，硬件更贵、密度更低，所以它占用了更多的空间，而DRAM在这种情况下更密集，更便宜。

所以缓存本身通常是主存子集的副本，例如，在我们的图书馆类比中，我们的储藏室基本上是我们的房间，里面有我们需要的十本书，所以我们从图书馆借来的，有很多副本，我们拿一份副本，呆在自己的房间里。

所以我们从我们正在查看的任何内存块中复制一份，把它放进缓存里，所以有时我只是想注意一点，情况并不总是这样，有时我们实际上在内存块上移动引号，从主存进入高速缓存，这被认为是独占缓存，基本上是在说嘿。

如果数据只能同时存在于两个地方中的一个，如果它在缓存中，它已经不在主存里了，如果它在主存里，它不在缓存里，我们将在这节课中讨论的更常见的形式，包容性缓存的思想，只是嘿，我们会在每个地方都有一个副本。

你可能需要它，这样你就不用重复了，你要重复你自己，但它可能更容易访问，大多数处理器都有单独的指令和数据缓存，因此，如果您模糊地记得数据路径是什么样子的，我们有一个单独的物品和一个单独的恶魔。

所以这些事情都是分开的，我们通常有一个眼睛现金，然后还有一个D缓存，所以有时你可能会看到它的缩写是这样的，因为现金，你知道的，我不认为你在伯克利以外看到一个超级普通的，所以如果你没有在网上看到。

这可能就是为什么，但这是一个有效的速记，啊，是啊，是啊，这是个好问题，所以要重复，主存和磁盘和硬件有什么区别，是在执行方面，所以磁盘所需的硬件，便宜多了，你可以在里面储存更多的东西，但正因为如此。

您可能无法以最快的速度访问东西，因此，在不深入硬件部分的情况下，嗯，磁盘本身将是一个非常便宜的，但真的很慢，所以就喜欢而言，实际上是怎样的，就像在，就像这些旋转的圆盘，你必须喜欢，等某，喜欢指针到喜欢。

与旋转磁盘上存储您的东西的位置相匹配，所以如果你在等待像这样的东西每次都在盘旋，你正在访问一些东西，或许可以开始理解，为什么这么慢，所以与其直接访问像，例如，随机存取存储器，你不必等待任何类型的指针。

只是去那个地方，磁盘就像你等待指针满足特定的磁盘，在你想要的位置，呃，这回答了你的问题吗，好啦，所以总的想法是我们已经唠叨了很多，如果电平离处理器更近，通常它会更小，也会更快，但它也会更贵。

所以这就是为什么有一个权衡，这就是为什么我们不能一直拥有所有的寄存器，因为它占用了很多空间，但它会更贵，所以你不能想吃多少就吃多少，所以它通常是较低级别的子集，又名最近使用的数据副本。

所以如果我们想一些我们在寄存器级寄存器上更熟悉的东西，凭记忆加载东西，但这并不意味着你马上抹去记忆中的东西，你只要把它复制到离CPU更近的地方，现在CPU可以在任何操作中使用寄存器。

在数据路径上解码等等，一旦我们处理完这些数据，或者我们想加载新数据，所以我们必须更快地循环，然后我们把这些数据移回或复制回主存，所以有点，呃，在最低层在线的问题通常是磁盘。

它基本上包含了你可能拥有的所有可用数据，在任何时候都可能需要，我拍我的电脑滞后对不起，所以记忆层次的概念，它能阻止处理器，通过做所有这些替换，产生了一种记忆非常快的错觉，所以它在说嘿。

主内存将存储许多您可能需要从磁盘中获得的东西，所以你不必每次都去磁盘，你需要访问一些，它会进入主内存，我的记忆还是很慢，所以我们要把最近访问的，也许事情，然后放到缓存里，缓存快得多，大概有十个时钟周期。

然后现在它会从缓存中拿走东西，然后把它移到寄存器中进行瞬时的单周期计算，整个过程，暗指多次使用东西的想法，因为缓存是速度最快的，最昂贵的内存和寄存器以及较慢的部分，即DRAM。

我们也可以把DRAM或主存看作是，嗯，缓存和磁盘之间的缓存，所以如果我们仔细想想，我们所说的缓存或主存缓存，它在主存和寄存器之间，但是主存是介于，比如寄存器或主存缓存，然后是磁盘，所以你可以这样想。

只是这一切都渗透了，缓存包含数据副本，然后内存包含磁盘上正在使用的数据副本，所以通常缓存工作在两个一般的两个想法上，所以时间与空间局部性的概念，所以她的名字和时间有关，所以它基本上是在说嘿。

如果我们在这个特定的时间步骤使用它，我们很可能会使用相同的数据或相同的，是啊，是啊，类似的数据在下一次，未来或近一步，而空间局部性的概念是说嘿，我们在太空中真的很接近，所以如果我们考虑空间。

我们用内存地址来思考事情，它在说嘿，如果我使用内存地址a，很有可能，在不久的将来，我可能会使用内存地址A加，所以通过平衡这两个想法，缓存能够表现得更好，比你想象的要多，如果你只有其中一个，是啊，是啊。

所以在我们的范围内，我们通常只认为缓存是包容的，所以主存有磁盘上的副本，它不只是把它从磁盘上移走，呃，主存储器缓存有主存储器中内容的副本，是呀，所以你有冗余，同一数据的多个副本，你还记得这个吗，哦耶。

DRAM代表动态随机存取存储器，这是一个术语，我们有时用来指主存，所以它是用来实现，呃，主存储器，很多时候，还有其他问题吗？是呀，是啊，是啊，这是个好问题，所以在网上重复一下，嗯。

如果我们有随机存取内存和存储的东西存储在所有的地方，我们如何使用空间局部性的概念，所以我想我们是怎么想的，所以随机存取存储器的想法并不像，哎呦，东西随处乱摆，只是意味着我们知道，为了说。

在10号地址找东西，我们不一定要通过和搜索，好啦，零一二三，访问前面的每一个地址，以便到达地址十，意思是我们可以直接去那里，但对于你的空间局部性问题，我们中有多少人循环遍历过数组或迭代遍历过数组，是啊。

是啊，好啦，所以回到Java，我们并不真的考虑所有的东西都储存在哪里，但是如果我们记得在C语言中，当我们使用数组时，我们知道数组从一个内存地址开始，然后我们逐渐喜欢，假设它是四个字节的中间层。

一号物品已就位，项二等于加四，第三项是加8，依此类推，以此类推以此类推，如果我们遍历一个数组，这是在利用空间局部性的概念，如果缓存运行良好，那样的话，因为它说如果我们期望遍历数组，我们要访问每个元素。

这回答了你的问题吗，我只是在重复其他问题，那么我们如何利用这一点来利用我们的行为呢，所以有了时间局部性的概念，基本上，缓存的想法是将最近访问的数据保持在离处理器更近的地方，又名在缓存中，而在空间位置上。

它在说嘿，我们将移动由相邻单词组成的块，也就是离处理器更近的每四个字节，所以基本上我们整合的方式，两个在说好，所以我们知道很多时候，我们需要访问记忆中很接近的东西，所以我们要移动一个街区，假设一字节。

所以十个，两个四字节一起进入缓存，所以现在这意味着如果我有一个数组需要使用它，然后我们可以遍历，所有东西都在缓存中，我们也不必不断地从主存向缓存中加载单词，然后利用时间局部性。

我们可能会在一两节课的时间里探讨这个问题，但是有很多方法可以把东西转移到缓存中，把东西踢出缓存，就像寄存器一样，例如，我们不只是有无限多的寄存器供我们使用，所以我们必须替换值。

有时你可能会记得这种奇怪的东西来回移动的事情，在风险五项目中，所以有了缓存，它们就更大了，但在某一点上，你也会被填满，所以你必须把东西移回主存，所以时间地点就像，好啦，那我怎么知道该把什么搬回来。

所以这节课我们就不会讲得太多，但是有不同的方法，他们各有优缺点，所以在缓存设计方面，嗯，我们谈了很多关于缓存的工作，所以说，我们实际上是如何设计它们的，所以第一个问题，比如我们如何组织缓存。

所以我们知道主存就像一个从零开始的胖数组，一直到最后一个可能的索引或内存地址，但缓存显然不是那样的，理论上，是啊，是啊，我们可以有一个与主存大小相同的缓存，但那样就违背了目的。

所以我们知道缓存必须小于我的内存，而且要小得多，也不太贵，所以我们得想办法把它组织起来，所以一般来说，这取决于我们希望缓存的行为，所以有三个主要的类别，我们将谈论很多，在接下来的讲座中，一个是直接映射。

所以我们不打算扩大这个，但直接地图的想法是说，每个内存地址都进入缓存中的特定插槽，在任何一点上，它只能进入缓存中的一个可能的插槽，所以它非常坚硬，然后在光谱的另一边，我们有一个完全关联的缓存。

所以这个名字，意思是你可以去任何地方，所以只要你有什么尺寸，假设我们有一个十二十四字节的缓存，所以假设我们想用直接地图把一口移动到缓存中，它可能只进入这个特定的槽，但对于完全联想，它可以去任何地方。

然后我们有介于两者之间的地方，我们称之为N种方式将介于两者之间的标题联系起来，所以它可能会分成一定的块，它可以在块的某个子集中有一些自由，但它哪儿也去不了，所以我们会讨论这个，呃，下节课。

所以另一个问题，实际的内存地址映射到哪里，我们要改变吗，内存地址为，我们实际上如何做好这件事，缓存是内存的一个子集，这意味着它操作的内存地址必须是相同的，作为它在主存中对应的内存地址，所以它不会改变。

现在的主要区别是缓存，因为它小得多，我们的内存地址不能直接去缓存地址，否则我们很快就用完了缓存槽，我们进去谈，还有即将到来的关于我们如何计算东西进入哪个槽的讲座，我们如何绘制事物的地图。

那么我们如何知道哪些元素在缓存中，我们不能随便检查，所以基本上我们的想法是通过首先访问缓存来执行内存操作，如果我们有我们需要的数据，所以系统以某种方式识别它，它说嘿，我有你需要的数据。

我们要把它带回CPU，然后我们继续我们的行动，否则如果我们找不到，我们只是去说，现在让我们继续进入主内存，然后从主存中提取我们需要的东西，将其复制到缓存中，然后将其呈现回处理器。

所以我们可以看到这里有两种路径，你不需要弄清楚事情是如何发生的，这是在系统层面上，操作系统会处理这些事务，但我们在抽象的层面上更多地讨论它，在接下来的讲座中也是如此，是啊，是啊，是啊，是啊。

完全正确是的，我们从来没有明确说过，我想在缓存中搜索，或者我想在主存中搜索，它总是，我需要这个内存地址，在缓存里吗，是呀，好极了，如果没有，然后做一个，还有其他问题吗？然后最后一个问题。

这种问题可能是好的，主存储器，我们知道我们必须经历并解决一些问题，在这种情况下可能会有点慢，那么我们如何快速地添加，找出东西在缓存中的位置，我们知道它很快，因为它要小得多，它使用不同的硬件。

但我们还是需要一个简单的方法，在那里，事情是如此暗示这个话题，我们有一个TIO分解或标签索引偏移量的想法，所以基本上我们使用一个内存地址，并把它切成块，然后使用这些不同的块来找出如何索引到缓存中。

以及如何再次获得我们想要的数据，这是一个即将到来的讲座，我们没时间了，我觉得今天，但是是的，这又是一次，粗略地，对许多主题的概述，我们将涵盖任何问题，在我们继续之前，所以我们有好的。

现在我们知道事物之间有很多不同的层次，我们实际上是如何管理的，当我们在寄存器和内存之间，编译器想出了如何映射这些东西，所以如果你看看，所以很多时候，我们直接编译到一个可执行文件中，但是使用GCC。

您可以编译到每个，或者我们可以生成所有中间步骤的文件，所以如果你用破折号的标志，您可以生成，嗯，可能是一个x86的汇编文件，但总的想法是好的，如果我们有一个程序集文件，意思是我们用寄存器。

因为我们从来没有在C或C中指定寄存器，加号加号代码，这意味着编译器以某种方式找出需要哪些寄存器，所以编译器知道什么，呃，现有哪些登记册以及如何利用这些登记册，以便我们的代码在缓存和主存之间正确地运行。

然后是这种叫做缓存控制器硬件的东西，你不需要知道这是什么，但基本上只是在系统层面上，它发现，好啦，我们如何在内存和缓存之间通信，我们如何来回移动数据，祝福你，然后在内存和磁盘之间，它被认为是二级存储。

它是由操作系统决定的，这里有个术语叫虚拟内存，别担心，这是我们以后几节课要讲的内容，但基本上它是在说嘿，如果我有这个东西在磁盘上，然后我需要它，我需要把它放在主内存里，我实际上如何在两者之间翻译。

因为我们的磁盘存储比主存存储多得多，我们都会忽略这一点，嗯是的，主存储器，也是缓存，所以一般来说，最后是缓存，它们基本上是对处理器的暗示，因此内存是无限大的，也是非常非常快的。

现在我们有了一个单一的缓存，所以我们知道寄存器是一个时钟周期，缓存在10个时钟周期的规模上，然后主存立即一百个时钟周期，我们有没有办法做得更好，那么有什么想法呢，首先，我想我们能做得更好吗，是啊，是啊。

看到一些一般的点头，有什么关于我们如何做得更好的想法吗，是啊，是啊，我们可以有多个缓存，嗯，怎么样怎么样，还有别的吗？好啦，所以是的，第一个总的想法是好的，如果缓存是寄存器和片上内存之间的一种缓存。

缓存是主存，实际缓存和主存之间的CIS，我们能在两者之间插入更多的关卡吗，所以我们在10个时钟周期和100个时钟周期之间架起了桥梁，所以答案就在，是啊，是啊，事实上，我们实际上可以做到这一点。

有多个级别的缓存是非常标准的，这背后的想法被称为多级缓存，我们简单地讨论一下，我想在第四或第三次，我觉得，嗯讲座，还有一个问题，我们的缓存总是会很好地帮助我们，它们会永远使我们受益吗。

我们中的许多人都认为是的，他们会一直帮忙的，有时候呢，是呀，好的，好的，所以是的，从理论上讲，现金应该总是帮助我们，但我们将在本周晚些时候和下周通过更多的例子再次探讨这一点，但这基本上取决于你想做什么。

理论上，是啊，是啊，就像缓存被认为是主存和CPU之间的神奇桥梁，我们应该能够有一些东西供我们支配，无时无刻不在，但在现实中，它并不总是这样工作的，呃，这取决于我们试图实现的目标，所以有很多东西可以根据。

像缓存，缓存结构，可能缓存大小，也许东西被替换的方式，能进入的东西，嗯，这也取决于我们试图访问的数据，根据程序，然后我想记忆访问的模式，我们试图访问多少数据，有很多不同的因素可以影响到这一点。

所以在最坏的情况下，事实上，有一个缓存可能会让事情变得更糟，因为，就像，如果我们仔细想想，嗯，如果我们试图通过标准，好吧，CPU到主存的访问需要一百个时钟周期，我们完蛋了，尘土飞扬，我们有我们需要的。

但是假设我们总是执行缓存行为的最坏情况，所以最糟糕的缓存情况，嗯，我们最糟糕的访问时间是什么时候，假设我们有一个10个周期的缓存，是啊，是啊，没错，所以这将是110个时钟周期，因为我们得先去储藏室。

那里有十个时钟周期，好的，好的，我们现在没有我们想要的，我们必须去实际上积极的cps现在去主存和访问，再加上100个时钟周期，你可以想象，如果我们有一个程序，神奇地利用了有史以来最糟糕的缓存行为。

然后我们实际上可以让事情变得更糟，这可能不应该发生，假设您有一个合理的缓存设置，你没有积极地试图利用现金，但是是的，很有可能，所以我们将探索解决这个问题的方法，我们可以测量缓存行为。

或者我们可以测量缓存性能，它在接下来的课程中表现如何，就像一个快速的喜欢，所以如果你有一台Windows笔记本电脑，你或Windows系统，然后你去你的，是啊，是啊，如果你去完成你的任务，或者别的什么。

然后你就进入了第二个标签，它实际上向你展示了正在发生的很多事情，就像我们这里，其实我是要去拉起来，我们有，我们还有时间，我想我已经涵盖了我需要的一切，嗯，不过，让我简单介绍一下，我在说什么。

所以如果我们看看这个，是啊，是啊，这是相当有趣的，所以我实际上要看这里，我意识到我没有，所以我们有我们的CPU，所以这就像我们在这里有一些尖刺，也许变焦决定扣球什么的，我不知道发生了什么事。

我们还可以看到我们有一定程度的内存使用，所以现在我似乎在用安静的一点，因为我有太多的标签打开，我们有我们的磁盘，这里的数据，挺酷的，这是我们的关系网，在这个班上我们不关心这个，嗯，我们有我们的GPU。

在这门课上我们也不关心这个，但更有趣的是，如果我们去CPU本身，我不知道是否有人能看到这个，很明显，我也不能放大，但我会经历，所以我们可以看到我们只用了15%到16%的利用率，它跑得非常非常快。

如果我们有一个旧的系统，也许像啊说，假设这里有2800台笔记本电脑，想做我们想做的事，我有更高的利用率，CPU会着火，就像，我需要完成所有这些测试，我没有足够的资源，然后另一个有趣的东西在这里。

所以我真的看不清那边的一些东西，所以我会试着从这里读出来，但我们的基本速度就在这里，我们CPU的这个基本速度，基本上，像多快的想法，你能走多快，我们有我们的嗯核心，我想就在这里，一共十四个。

在这种情况下，所以我们的物理核心，我们有十四个，我们的逻辑处理器，我们有，我想二十个，是啊，是啊，二十个我看不懂其中的二十个，你不必担心两者之间的区别，但基本上这个想法就像硬件中实际存在的东西。

与硬件中不存在的东西，我们假装它们存在，然后我们启用了虚拟化，现在不要管那个，然后我们有我们的L，两个，两个和三个藏匿处就在这里，所以我把它藏起来了，上面说我们有1。2米。

但它实际上可能意味着这里的字节，然后对于l 2缓存我们有11。5然后l 3，我们有两个四，我相信这就是，我想可以，但这里的想法是，我们将讨论这种更多层次的缓存，但是lone缓存离CPU最近。

两个隐藏处在1和3之间，三个都在l2和主存之间，我们可以看到每增加一步，它的大小增加了，这意味着它的实施方式可能更便宜，而且密度会更大，又名你可以在更小的空间里有更多的存储空间，但是因为我们有。

它也会逐渐变得更慢，所以如果我们把所有这些想法，就像，好啦，我们从cpu到lone，是不是没有，现在去L 2，是不是没有，那就去三楼，如果不在那里，然后我们去做，但是是的，这只是一个简短的插话。

我不知道你是怎么把这个弄到麦克斯身上的，互联网可能会告诉你，很抱歉，我不使用max，嗯，但是是的，这只是一种很酷的东西，呃，或许能帮助你理解，是啊，是啊，你的人在网上说，系统层面上到底发生了什么。

我说话用我说话有人试试，是啊，是啊，嗯是的，好啦，让我看看能不能重新开始演示，哦耶，我真的能看到东西，是啊，是啊，呃，呵呵，好啦，所以说，如果我没理解错你的问题，就像对程序性能的理解，我们就像对待。

啊抓住你了，我想这取决于你问谁，因为如果你问，就像，呃，可能是七十人或六十一个B人，甚至当我们谈论渐近之类的概念时，就像是把它们当成恒定时间的操作，好的，好的，假设在硬件上一切都很好。

这里有一个关于事物应该如何表现的理论，如果我们有这个，嗯，这个程序在理论上，就像我们可能会做这么多的手术，它是如何缩放的，但如果你说到实际的表现，实际上，能够像基准一样，像时间一样，表演中的东西。

你不会想那样对待它的，你会想要像，好啦，如果我想最好地优化我的程序，我应该喜欢那种啊，知道我的缓存有多大，我怎样才能充分利用这一点，所以这就像，如果你把时间压缩到这样的水平。

你基本上想试着把东西最大化到你使用的任何硬件上，我认为渐近不，因为它的大意是，因为就像渐近线，不要依赖任何类似的特定数字，对呀，它依靠的是，就像，好啦，所以根据输入的数量，我该怎么表现，所以它其实。

它不依赖于任何与硬件相关的东西，所以我会说不，嗯好吧，是呀，让我重新开始。

看着就像我的老鼠在那边滞后，然后就像慢了三倍，很有意思，嗯是的，好啦，所以有点超越了，所以是的，总结一下我们只有五分钟的时间，所以有足够的时间来得出结论，对于任何遗留的问题。

我们已经学会了如何在处理器和内存之间架起桥梁，嗯，我们如何再次弥合这一点，缓存，我听到外面回响，嗯所以是的，我们还探讨了缓存对访问延迟的潜在副作用，又名如果你一直表现不好，然后你实际上会增加你的潜伏期。

我们还为接下来的三节课探索了一些更大的图景，所以不同类型的缓存行为，所以你如何访问东西，你如何分解事物，您有多级缓存的想法，又名，如果你有不同的缓存结构，在不同级别使用不同的硬件。

这如何改变我们的延迟和访问时间，也可能是我们如何测量缓存性能，我们也谈到了如何支持存储系统，我们如何利用缓存优势，所以我们试着说，好啦，让我们试着，也许构造我们的数据或访问它。

所以它遵循时间或空间的局部性，这是我们绝对不能做的，那就是，我们会在家庭作业的一些例子中看到这一点，然后嗯，你会在过去的考试中看到，也许在课堂上也会看到，但就像，假设我们有一个数组，啊。

我们可以同时将一半的数组加载到缓存中，假设我们有一个由十个二十四个字符组成的数组，所以十二十四字节，我们的缓存将是5 12，全联想，所以就像，数组的一半现在可以同时进入缓存，如果我们说我们进入，好啦。

假设我们访问索引零，你觉得我们会有什么样的行为，我们会直接在缓存里找到它吗，看到几个摇头，所以是的，如果我们试图访问索引零，在储藏室里是找不到的，因为我们还没把它带进来，但因为现在我们访问索引零。

我们要去回忆，从理论上获取缓存的五十二部分，然后把它插到，嗯，或抱歉数组，然后把它插到缓存里，现在我们在缓存中有512字节的数组，现在我们的下一个操作，假设我们在偏移量5 12处访问数组。

我们认为会发生什么，然后呢，我们在缓存里找到的，有几个摇头对吧，所以我们实际上并没有在缓存中找到它，因为缓存的位置是0到5-11，因为它有512个字节，512就像现在的指数是513。

所以现在我们必须回到主存，我们看到了这可能会有什么不好的表现，所以我们没有利用空间局部性的概念，在这种访问模式下，因为我们就像，我们真的跳过了我们刚刚加载的所有内容，在接下来的课程中我们会看到更多。

这怎么会真的真的很常见，然后性能代码行为，这也是因素之一，差不多就这些了，我有，嗯，是呀，有什么问题吗？感觉有点，哦是的，怎么呃，好啦，那么缓存如何影响数据路径中的时钟定时呢，对嗯，所以一般来说。

我想影响，就是有就是有，所以说，我想丹可能会在以后的课上钻进去，我不是百分之百，当然可以，但是理论上，它的工作方式是，它应该有点，我想已经考虑到永远不会要求你时间，就像数据路径方面的事情，就像，啊。

如果你在中间加三个缓存，像记忆一样，这会对事情有什么影响，嗯，我们将探讨平均内存访问时间，因为我们不可能预测代码的行为，在运行的每一个程序的每一个实例中，所以我们把它摊销，好啦，这里有一个大致的估计。

事情的平均值，事情会如何发展，我想回到盒子里，就像，我不知道丽莎能不能回答那个问题，更好，啊，对不起，简短的回答是，呃，如果你不能，我不知道谁在回答这个问题，你还好吗，是啊，是啊，所以简单的答案是。

如果你在拿东西的时候没有，然后一切都停滞不前，然后你花时间，所以如果你真的看看上一张幻灯片，上一节课的最后一张幻灯片，你会看到有一笔很大的费用，必须从记忆中提取东西，这就是许多减少的地方，呃。

上升的cpi来自，是啊，是啊，好啦，我们正好十一点，所以是的。

P33：Lecture 25： Caches-Direct Mapped II - 这样好__ - BV1s7421T7XR

天哪，我脑子里一直在赚钱，夫人我我我的现金，我的宝贝宝贝肿块，婴儿现金带婴儿婴儿现金带婴儿现金。

敞开心扉无时无刻不在赚钱，然后这么多我把A看她最好，我弥补了我的，他们走了，我对她说了这么多，当我没有我的，他们走了，你在节目中看到这个就在你的心脏，我左边那个，我有权在前面兑现给我。

我应该回去，叫我CA，你从我心里的现金里给了我一把刀，无时无刻不在赚钱，这么多这么多漂亮的宝贝宝贝。

那漂亮的现金，我脑子里的现金，无时无刻不在赚钱，也许我应该直接把现金给我，我不应该有人给我现金，当你得到表演的钱，无时无刻不在赚钱，把我打晕了。

当我们得到。

一二一过去。

让我们看看这是否也有效，我这里也有一个视频，我们总是从我们的计算开始，新闻有点早，这样我们就不会浪费上课时间了，很高兴见到你们对不起，但我需要解除静音，谢谢你，谢谢你，谢谢你需要解除静音，不知何故。

不知何故，我怎么静音了，静音，静音，我是，我不是，是呀，我不是，我不是哑巴，是啊，是啊，好啦，谢谢，谢谢你的小费，很容易被困住，好啦，这就是视频，好啦，所以嗯，计算新闻，欢迎大家回来很高兴见到你们。

你们都开始正式计算新闻，当计算机，消息来自伯克利，这是国家新闻，伯克利为人工智能实验室制造了一些新闻，所以加州大学，伯克利混合机器人实验室，能有一个迷你猎豹机器人和谢里夫在一起吗。

你知道这就像国际足联世界杯赛季，我们对此感到兴奋，希望你们都对此感到兴奋，我对此感到兴奋，可以救八十个，七点，5%的射门，这是一个小婴儿进球和一个小垒球，这不是正式的足球，就像全尺寸的，但很不错，嗯。

研究人员指定或设计了四足机器人，集成运动控制器，带有末端执行器轨迹的规划器，找到最好的机动方式，在球前面不到一秒钟，所以这很酷，我想给你看一个小视频，如果成功的话，我想我得点击这个按钮。

我觉得这个麦克风，这是我在YouTube上看到的一个很棒的视频，这一定行，我把它嵌入，它现在应该开始视频了，我点击，它不工作与点击，点击声，点击声，随着咔嗒声，这是我的视频，好啦。

去去视频去速度赛车手去，我不知道发生了什么事，点击，点击，点击，好啦，嗯，有一段球打机器人的视频，我不知道为什么它不快乐，呜呜，我嵌入了YouTube，我能出去吗，这是值得的，我会看YouTube视频。

所以这是一个YouTube视频，他们看到科技新闻，那真的很烦人。

这是头条新闻，从这个开始，好了伙计们，十月份去这里是值得的，然后十九，给我点东西，给我点东西，给我的东西是，我从哪里得到这段视频，守门员来了。

你在找文章。

有机器人做这件事的视频，这是我嵌入的，它应该起作用的，在这里行不通，我们走，给我一点声音。

当你在底部打开，但碰巧本身看起来很棒的是，所以说。

机器人最好的部分。

别再在街上打架了，向上反击一直到最后，世界，他们让我出去，直到我们到街上，你呀。

好东西，展示我们Colle的一些工作的好东西。

离开那里，离开那里。

啊那里那里，这样就完成了，关上它，然后回到这里，下一张幻灯片开始吧，好啦，好吧，把这个关了，把我们关了，今天是星期五，所以我想在星期五找点乐子，好啦，欢迎回来很高兴见到大家，欢迎来到CS六一C。

我想特别感谢卡洛琳，至少很明显，但是卡洛琳特别为精彩的演讲，他们有多棒，让我们为他们鼓掌，太棒了，好东西，我们正在为我们年轻的教师做好准备，精彩，所以我们说的是缓存，你看到这是个新话题了吧。

我们在管道上按下了重置按钮。

新话题，所以让我们深入挖掘并建立我们的第一个缓存，挺刺激的，我们将称之为直接映射缓存中的直接映射缓存。

是什么让直接地图变得容易，直接是最简单的计数，顺便说一下，一般直接地图是最容易捕获的一种，Y，因为每个地址只与一个地方相关联，它可以去，你记得卡罗琳说过，记忆金字塔，内存层次结构，缓存通常是更快更小的。

更昂贵的比特空间，我们可以保留一个副本，我想让你知道，如果你还记得记忆的概念，记住记忆应该如何在61年学会这一点，这个想法是你有一些非常复杂的，就像斐波那契或其他需要，如果你只是用天真的方式写。

在一百上运行斐波那契需要大量的时间，这是做不到的，但如果你一旦解决了一些问题就记住了它，你解决了任何谎言，一些数字是你记得的，下一次你打电话给斐波那契，你说我有这个吗，我已经计算过了，我有。

我就用这个值，这就是独联体，所以如果你想连接到软件，它的侧面抓住了，或者像记忆词典，或者你想用的任何东西，这让东西，因为你不想去萨克拉门托，你还想再次计算fibonacci的fib值。

如果你已经做过一次，就是这个意思，好啦，所以只要把它和你联系起来，所以在直接地图缓存中，如果我有副本，我必须知道它在哪里和一个直接的地图缓存，我只知道一个地方，它可以在直接的地图缓存中，所以这真的很酷。

我们不必看一个，让我们看看你想看看我有没有，我先走了，它通常在这里吗，这是我保持它的地方，它不在这里，所以我没有，所以不是说，我得去找，我没有马上拿到，我知道这很重要，直接地图缓存很容易。

一个块是和卡罗琳，你提到过这个，块是高速缓存和内存之间的传输单位，所以我们要把东西分块转移，不是字节也不是文字，但以块为单位，我们就是这样从记忆中来回移动东西的，然后缓存会有一个块，也称为缓存行。

就像吵架一样，这是一排，我们会看到的，好这里，这是第一张真正现金的照片。

哦我的天啊，所以让我们停下来思考一下，这是我的记忆简化的想法，一口一口，当你考虑缓存时，这真的很重要，知道如何，你为什么这么说，这是一个字节宽，左边的地址，很简单，这是我从零开始思考记忆的线性方式。

一直到底部的八个F，很简单，我用四种不同的颜色给它编码，为什么？因为我会有一张直接的地图，让我们读单词，四字节直接映射缓存，一个字节块大小，一个字节宽，它的宽度是一个字节宽，查看块大小，一个字节。

那么这意味着什么呢，这意味着我要读到记忆中的某个地方，事情是这样的，每个忧郁的人，你认为这是一种模式，四分之一进入第一个槽，让我们暂停一下，确保你明白那是什么，所以现在再也没有问题了，在缓存的什么地方。

我基本上是说，你是什么颜色，就像，我说，你的地址除以4是多少？所以它就像模四，如果是零，那你就是四的倍数，你是蓝色的，如果是一个，除以四后余数的mod是1，你会变红的，这有道理吗，所以让我们保持。

我们记下你的地址，基本上我们要看多少位，找出它应该在缓存中的位置，让我们现在想想，谁想说，我怎么能只看，以比特为单位查看剩余的mod，如果我们要找的是，我该怎么做呢，这里还有一个，我得到了三个两个比特。

我要看什么才能知道它在模组4中的划分是什么，四件事，所以第一个，两位，前两位，下面的两位，如果你把某物除以四，下面的两位告诉你4，让我们数数，零是多少，零的前两位是什么？1的头两位是什么？

2的头两位是什么？三三的头几位是什么？四零的头两位是多少？看看它是怎么做到的，前两位是一个零，四一一零是多少，所以它是前两个部分，是下面的两位，这就是我所做的一切，所以我看着你的两个位。

这就告诉你它是什么颜色，如果是两个零，是蓝色的，那不是很酷吗，一定要让每个人都知道，我有很多尸体，你说我有四个字节，我得到了这是，这是一个二到三二数组，然后我有两个到三十个或一个gibi。

还记得卡罗琳也说过一个吉比，我有一个吉比，蓝色的东西，都映射到同一个蓝色的东西，这是正确的，你可以找到他们去哪里啊，我们来谈谈我怎么回去，我们会谈谈，我只是不知道怎么把它放在那里。

我只想知道怎么把它放在那里，我不知道是不是这样，所以这里的亚当真的在问，如果我储存蓝色的东西，假设我把它储存在，在那里有八条生命，我怎么知道是八点，这就是你真正的，我觉得，这才是你真正想问的。

我怎么知道它来自八个，我们会尽快解决的，但你问了三张幻灯片，我只想确保人们知道它会去哪里，然后我们会有更多的工作来找出它来自哪一个，那很清楚，好的，好的，到目前为止一切都好，只要确保，好的，好的。

你看这幅画的下两位，我知道该去哪种颜色，你就去吧，在那里一切都会好的，所以这就是我现在说的所有话，但我要给你看这个东西，这里的现金可以从零四八任何倍数到四，四个街区，只有四个街区，四排，宽度为块大小。

所以这四个方块，我看到四排，任何4的倍数的内存位置都在那里，如果我们想要一个块大于一个字节呢，对我好点，能够在同一时间或此刻阅读一个单词，所以让我们在图片中做一个改变，以获得块大小，也许更大，一个字节。

我们现在开始，让我们暂停一下，现在看看这个，我有一个8字节的直接地图缓存，我所改变的只是块的大小，我改变了宽度，我不仅没有字节宽，它有两个字节宽，好吧，到目前为止，到目前为止，一切都好，顺便说一句。

现在，让我们假设我们读的是写字节，因为它有点复杂，如果我写的话，暂时是重叠的，现在只读写和字节，让它变得容易，只需通过它的存储加载非常简单，那么这又是如何工作的呢，每一个蓝色映射到每一个蓝色。

但它不再是我们最低的两个位了，是吗？让我们想想这里发生了什么变化，我怎么知道，感觉就像两块，那里有四样东西，所以它必须是一些二位，但它不再是最低的两个位了，之前是零四八现在看起来是零和一都变成了蓝色。

八号和九号都是蓝色的，所以这肯定不是最低的两位，但有两点告诉我，它是两个直接位，我只是抓住这些碎片，我看着它，但这不是最低的两个，我们能弄清楚是什么吗，从那里过去了一个，所以它不是最低的比特。

就像碎片一样，如果之前是0和1，现在是1和2，就像这两个，只是一个以上，有道理，我看着这两个部分，完全正确，在某种程度上，这里是有趣的，最低的部分会告诉我这张照片里是什么，哪些是蓝调，那不是很有趣吗？

所以让我们记住，最低的比特是，告诉我区块中的哪个字节，看看这张照片，下一个，下一组位将是哪个块，我有，我对亚当的问题仍有答案，如果我有一个蓝色的，我怎么知道它是从哪里来的，它是从零来的吗？

它是从八九来的吗？它是从右边来的吗，所以这是个问题，十和十一，好吧，在十六进制中，那是十六进制的，顺便说一下，这个在左边是十六进制的，顺便说一句，大家可以看到，很明显它有a和c和e。

所以我们要求一个字节，控制器，有一个控制就像，谁在跟踪这个，我提到过这个，有一个缓存控制器，记录这一切，所以你不用担心，这不是你的工作，这是硬件中缓存控制器的工作，真的很不错，找到正确的块。

并把它加载得很漂亮，它怎么知道，哦这里，它是，这是亚当的问题，我怎么知道正确的街区，我如何选择自行车，我们已经讨论过了，当右方块是时，两个位就结束了，从，那是块，正确的字节是最低位，如果是零。

这是最右边的一点，如果是一个，是左边，是左字节，零，是正确的字节，这是一个，是左字节，我应该确保我说的是对的，最低字节在右侧，是啊，是啊，最低字节在右侧，所以一个正确的正确，是啊，是啊。

原来如此事实上这东西管用吗？呃是的，在这里，我们走在这里，我们走，好啦，看，这是最低的一口，较高的字节和最低的位，零会在这里，一个会在那里，零会在那里，一个在那里，最低的，如果我查看内存地址。

最低的一点告诉我，右边是零，左边是最低位的，这在这里是相关的，我就是这样储存东西的，好啦，我就是这样推的，我就是这样把一个词放进记忆中的，这只是在想这个，所以，哦，在这里，我们去内存地址一，一，一。

哦一个，有什么问题，我想问一下，我们该怎么办，让我回去，我要为1101做什么，让我们滴水，好啦，我去一一零一，它在右边这张照片的什么地方，嗯，让我们说一个一个一个，左边那个是什么？左边是从哪里来的。

我是说你可以说，它在左边的什么地方？你能你能弄明白吗，这是一个强大的东西，一一零一，糟糕的是，较慢的方法是拿一个，一个，一个，把它转换成十进制，然后你在玩一些十进制的地址，然后你把它移回十六进制。

或者你可以聪明一点，把它放在二进制空间里，直接从二进制变成十六进制，一对一是什么？直接十六进制零一，不用去十进制，你能做到吗你还记得吗，当你从二进制到十六进制，这是在你期中考试的时候，你从左边开始。

你从右边开始，所以在右边，也可以拍拍从左边开始，你得记住衬垫，所以从右边开始，什么是最低的尼罗河，好像是一零一，我记得所有是4的倍数的，就像那些正常的字线，东西是零4 8和c所以当牙齿最后2位到零时。

它是一个C，所以一百，那不是，那不是零的两个比特，这是一个在那里，所以这是d和左边，左十六进制值是1 so 1 d so，我们在往下看，我们到下面去，我的光标呢？让我们得到它一秒钟。

我的光标A光标返回一D，我把它搬到这里来，这是一个C，那是一天，是那个家伙，这就是我们想要的，好啦，我们想抓住它，没有缓存，我只是在这里回忆，抓住那一口，所以一定是那边，见，地图就在那里，如果它在左边。

它将在这里的左边，它实际上是一对一的映射，见，一定在那里，我能通过看这些碎片就知道吗，让我们做吧，最低位是1告诉我它在缓存的左边，另外两位读为一个零，那是两个，得到它所以看看看，刚刚好，我们做了。

我们是在头上做的，我们开始吧，最低位的意思是在左边，接下来的两位是一个零，所以一零等于二，它就在那里，所以它在那里，所以我们可以做到，你可以用两种不同的方法来确定颜色，然后计算出箭头的方向。

或者只是看看这些碎片，我们谈过的，好吧，到目前为止，一切都好，这是关键问题，我怎么知道它来自哪个橘子，又来了，这是关键问题，我们得想个办法，我们还没有给你一个解决办法，这是我的，这里是我加的这个。

你们在行李认领处是做什么的？旅游业出现了一场运动，假设大约十五年前，在那里，每个经常旅行的人都买了同样的黑色面包卷，它大约有十二或十五英寸宽，大约二十英寸高，从字面上看每个人身上都有同样的卷。

看起来都一样的行李，他们都会站在SFO那里看着他们，他们看起来都一样，人们必须，哎呦，他们会怎么做，他们是做什么的，他们，他们检查标签，从字面上看，我们称之为标签，我们要在这个上面加一个标签。

想知道它是从哪里来的，就是这样，如此循环，我们把它包回去，我们添加标签中应该包含的内容，它从哪里来，就是这样，它就放在它来的地方，你进来，我知道该去哪里，我看着这些碎片，知道去哪里。

我看着那排我看着标签我说，这是我请求的内存地址，这是存储在此标记中的内存地址，现在是对的吗，我知道就像一个措辞，钥匙在字典里，它就在那里，如果它在那里，它是我的，那是我的排位，我拿到了，在缓存里。

快速创建，如果不是，它不在那里，现在我们要假装，我们只做阅读，我们不是在写记忆，我们只是在看书，我们只是在那里检查，只是阅读，记住，就像一本大字典，这是一个只读，就目前而言，读书写字要困难得多。

都在这里阅读，你们有多少人要去，每个街区不都应该是自己的吗，我不知道那是什么意思，你知道的，我是说，埃尔的观点是肯定的，所有住在那里的东西，就像同父异母的兄弟姐妹住在一起一样，就像他们来自。

他们出生在世界不同的地方，但他们现在碰巧在同一所房子里，这就是我们得到的，很难为每一行构建缓存，你想有一个缓存，按我们现在的方式处理，所以我们不会尝试为每一行建立一个新的缓存，这是我为你做的事，我有。

如果我把它的方式，这是最重要的，顺便说一句，如果你在做字幕，这从来没有教过我，我想要你，我看另一个现金，他们不教这个，这是一个特别的Danelisa的东西，当你抽到现金做这个的时候，做这些问题。

我要你画缓存的宽度和画内存的宽度完全一样，所以另一种方法是绘制缓存的宽度，它有多宽，你的街区有多老，方块的宽度是多少，它有多宽，这里有两个字节，我要你画一个完全一样宽度的记忆，不要画记忆，就像一个字节。

宽阵列，绘制与缓存完全相同的内存形状，你看我说的一样宽，这就是为什么一旦你这样做，然后你可以想到这整个缓存，在这整个缓存中，每两周我要花一秒钟，就像从字面上看，它完全符合那张照片，应该是一模一样的。

如果这个是一个宽的，很难弄清楚地图，但是通过画完全相同的宽度，然后你在房间里有很多回声，所以我有点热，那么这个宽度和他的记忆是完全一样的，现在你能做的就是把这个缓存，做一个盒子，做一个大长方形。

然后把这个长方形，把它画在这里，画这个长方形，画这个，画那个是一个完整的缓存，意义，如果我们开始打数组0 1 2 3 4，无论缓存大小如何，它真的会填满它，一旦填满，然后看看下一个尺寸。

所以我要把这个叫做，这就像缓存号为零，从下一个蓝色到这里的下一个是第一条，看到了吧，通过这样做，我现在可以想到哪个缓存大小的内存块，我正在读，这是这里的关键，上面的是零，然后一个，然后两个，然后三个。

我一直在往下走，我叫它缓存号，你马上就会明白为什么这很有趣，所以我需要整个地址都在标签里吗，我们总是想节省比特和保存，我不需要有很多多余的部分，如果我不记得了，当我们写的时候。

我们记得我们实际上写了什么，当我们做一个跳跃或树枝，你写所有的部分，否，因为我跳到了单词对齐或半单词对齐的东西，所以我留了一些，我必须把所有32位都放在我的标签里吗，或者我可以扔掉一些。

其中一些是我所在的行，这两块，其中一些是我在哪列，我需要这些碎片来告诉我它是从哪里来的吗，否，那是关键，那么我还剩下什么，如果我把这些碎片拿走，我还剩下什么，缓存号，那不是很整洁吗，我画了那个缓存。

我有这个缓存号，零，一个两个，这样我就可以把它们划掉，嗯，我们做了这个，记住，我刚才说的，当我做即时地址时，我数一个不，我不能买四个，我不能选择在哪里做，所以说，为什么不按现金号码数呢，哒哒哒。

以与块大小相同的宽度绘制内存是很有用的，我已经说过了，我把它划掉，我写，我们回去吧，八个要多少，什么现金号码是8，八个在一组，如果我如果我八个在一个，记住这一点，这个蓝色是唯一一组，这是唯一的现金号码。

那两个在哪里，那是零组，十四在哪儿，那是在两组中，哪儿有一个，三组中的E，所以我把它们划掉了，我写缓存号，很酷吗，所以基本上是所有的部分，但我用来计算我在哪一排的部分，我在哪个专栏，这里有三块钱。

我怎么知道是三个比特，因为它是8乘缓存2到3是8，所以我扔掉了最低的原木底座，缓存大小的两个，这就是我扔掉的碎片，剩下的部分是我的标签，就是这样，我们再来一次，我的缓存有多大8字节，多少位。

我需要给8字节缓存中的每一个字节寻址3位，所以我把这些扔得更低，更低的三个比特，记住最低的是哪列，我在中间，或者这三个中更高的是我所在的排，请记住，之前剩下的高位是我们用于标记的位，就是这样。

这就是大局。

这就是我在那里用的，它是，那是我的照片，我甚至没有彩色编码给你看，大多数地址看起来像，让我们一起做吧，这是容易的，我知道这很复杂，但这是最简单的，你能再硬一点吗，从这里开始，直接地图缓存的问题。

所以由于多个内存地址映射到同一个索引，我们怎么分辨哪一个在里面，就是那个标签，或者我的缓存号，是那种，在第一行零，下一个缓存大小，那是一个等等，现在，如果块大小大于一个字节怎么办，我们刚刚看到。

我需要三个字段，就像我们看到的，用于计算它在一个街区内的位置，这些告诉我我在哪个专栏，我今天大概要说十遍，希望你喜欢，哦，我明白了，好啦，较低的位是偏移量，它告诉我在街区的什么地方，哪个字节。

我想把接下来的部分，我的索引，告诉我哪排，我想知道哪个街区，我想吵架吗，这是下一组比特，剩下的是我的标签，所以我不必三个都用两个，我可以用这个，顺便说一句，这里是很酷的部分，这些总位数，如果这是。

会很有趣的，如果这是哪列，这是哪排，行时间列是面积，那是我缓存的大小。

我有那口井的照片，我只是把它描述得更多，所有领域都记得我们说过的，这很重要，就像我们说的，我吃了点东西，他们在编码什么，当我谈到浮点，当LISA提出浮点，这些位有不同的含义，这些是有偏见的编码。

这是标志，幅度编码，这是现场，记得有三块地，你记得有个选择题，有多少不同的格式，我需要储存，减去十二点，七十五，那是遥控器，对呀，人们我没有给你答案，我说你会听到答案然后飘起来。

答案是浮动中的三种不同格式，左边是符号星等，中间那个有偏见，右边的是无符号的，三种不同的格式在这里存储它们很容易，全都没有签名，这里没有消极的东西，这容易多了，但你现在记得三三了。

为什么我记得我说过是从左到右标签索引偏移量，但我为什么要在这里列出它们，我在这个顺序索引偏移量标记中列出它们，因为这是命令，我们检查他们，这是件有趣的事，索引告诉我我想要哪一行，奥菲说它是什么颜色的。

我想要哪个字节，现在我准备好得到字节了，但现在我做的最后一件事就是检查标签，确保标签是正确的，所以指数，行偏移量，如果，如果标签正确，是我的黑包，我可以从SFO回家，和所有的东西玩得很开心。

我合法合法地走私入境，我只是说法律上，好啦，你明白了，所以第一个索引，哪一行，哪个块偏移量。

检查哪一栏标签，并确保它是你的，好吧，到目前为止，一切都好，这是我做的照片，这从来没有作为这张照片的项目介绍过，我喜欢这张照片，因为我是视觉学习者，我觉得图形是个博士，我需要照片，那么面积是多少。

我缓存中的总字节数是多少，它是高度时间的乘积，宽度，这就像从一年级到一年级，二年级，方块的高度是多少？宽度是多少，块大小，这大概是，你可以听到我一遍又一遍地说同样的话，希望低连接。

我甚至把其他幻灯片的颜色保持不变，T tag guy索引在西班牙语中从西班牙语中的西班牙语偏移，西奥的意思是叔叔，所以只要记住西奥丹谢谢你，西奥丹教一些西班牙语，都是一、二、三的声音。

你说tio dio的意思是叔叔，tio是你能记住哪个顺序的方法，T在左边，都在中间，右边的O，就是这样，谢谢丹叔叔，我忘不了，现在你知道哪个是和和或哪个图片了，记得我给你的小礼物。

我给你这个西奥作为另一个助记符，所以这张照片，你觉得这张照片没问题吗，最右边的位偏移量告诉你块中哪个字节是宽度，索引最左边的位是您想要的块，标签是东西。

你检查最后一个好吗，让我们举一个例子，假设我们有八个字节的数据，好啦，缓存直接映射中的八个字节，或者两个街区，我们刚看到那个问题，那是二乘四的问题，我们刚刚看到它决定了标记索引和偏移量的大小。

如果我使用32位的架构我们已经这样做了，你大概已经知道了，但让我们一起慢慢做，偏移块中的字节数，嗯，块是两个字节，它有多宽，我们从偏移量开始，那是最慢的部分，有多少列，我有很好的，它告诉你问题告诉你。

它是一个两字节的块，每个块是两个字节，我有两样东西，那里有两个字节，多少位，我需要确定两个字节中的哪一个，我需要一点，好啦，所以现在的偏移量是一个位，一旦我这么做了，现在我知道这是一个简单的问题。

这实际上是一个二年级地区的问题，我已经告诉过你长方形的宽度是2，面积是八，它有多高？那么这是多少，它有多高？四二乘四等于八，索引四个不同的行需要多少位，二，就是这样，看到了吗？这是怎么回事，还不算太糟。

对呀，那个领域的知识真的很容易，整个街区，整个地窖都是我的地盘，宽度是块大小的字节数，高度是我的方块数，就像十个，这就像，我是时间我的数字六，我要去十次，一遍又一遍地告诉你同样的事情，所以这个是两个位。

许多块标签是剩下多少好，我已经保存了一个和两个，一加二等于三，三二减三等于二十九，29位标签，我们刚才说，为什么不扔三十二块钱，为什么废物吐口水，我们知道为什么浪费不想要不想要，不要浪费唾沫。

不需要用所有的位，反正我也要看看。

让我们做吧，哦我的天啊，我们会有真正的代码，太神奇了，这里，我们去真正的代码加载字，第一个是我的基本指针，零偏移的东西在调谐块，零p一包含十到二十二，十进制十进制，好啦，不是十六进制十进制。

在那个内存地址中，我得到了99的值，这是老派的，你就是这么做的，当你学会什么加载词，处理器会打招呼吗，记忆先生，记住这个记住处理器图片图片内存图片，记住这是这里和右边的输入输出，启用所有这些东西。

处理器说我要你的东西在10点22分，内存将地址发送到该内存块，说十点二十二，外面最好有一些数据，它是一个组合逻辑元素，我在阅读，就像漫画一样，甚至不同步，随便啦，不管多快，它可以找出地址。

它会给我一些价值，在最后得到99，发送处理器进程，谢谢你这么多的东西，我会继续前进的，继续前进，这就是加载词的作用好吧，容易，当有现金时会发生什么，让我们做吧，前两个是同一口井，第一个是一样的。

但这不一样，你先看缓存，你说我想要价值，一切都不一样，你看，而不是去回忆，现在我知道这是一个缓存，上面说我要先检查缓存，就像你在记忆课程中一样，一百个谎言，那是一个很大的计算，我希望我的字典里有它。

如果我真的用这个值，跟我们现在做的一样，跟我们现在做的一样，所以我问缓存或我的非常快的存储，我有十二十二吗，我过去要过二十二吗，它在我的缓存里吗，缓存以查看，如果它有它的副本，如果它找到了，算命中吧。

这是一个暴力，那件事我很抱歉，很受欢迎，它显示缓存读取它比去萨克拉门托快得多，顺便说一下，还记得萨克拉门托吗，进入记忆，真的很痛苦，现金真的很短缺，就像在校园里，找个地方让我去拿，是呀，这是我的办公室。

所以我们去抓，它，从他的办公室，把它带回来，我们都很高兴，点击率很高，我们喜欢孩子，当我错过了，哦，现在我错过了，它也不在那里，因为有其他人在场，或者因为我从来没有要求过什么，它是全新的，重新开始。

启动，那么它是做什么的呢，它必须去记忆，在1022处读取值，内存得到99，发送99到缓存，带着地址，他说，取代了在任何平方十二十二放在缓存中的九十九的词，所以下次我要求的时候，它在那里，这真的很重要。

就像你记得的那样，记住记忆，我没有一百个谎言，哦男孩，我去算一下，我等了一百年，我回来了，我把它塞进去，所以当我要一百个谎言的时候，下次我拿到了，这正是这里发生的事情，如果我，如果不是现金。

我得去做它去找它，意思是去萨克拉门托，然后把它放在我的短期斑点上，现在它在你的收藏夹里，现在它在你的收藏夹里，在你的手机上，关于你最近的研究，那是最近的事，因为它是我们的最爱，回你的电话。

你最后打电话给她，你的理由实际上是一个缓存，把手机拿出来，那是你的现金吗？这难道不比去看你的地址簿，艰难地通过没有好吗，我想我最近给丽莎打了电话，有那么好，是同样的想法，所有这些类比都与，是呀。

喜欢的结果，你觉得怎么样，保证是在那个哈哈哈好问题，我怎么保证会是那个地方，我们是直接映射的，直接地图意味着这些片段告诉我那个家在10点22分的确切位置，我看了最低的部分，告诉我什么样的行。

我要去哪个专栏，我要成为，我看下一个位索引告诉行在哪里，我现在进来了，我知道该怎么找，我检查了我的标签，标签上写的是十二十二还是其他的，移除的下位，相当于1022的标签是什么。

在我从缓存区域中删除较低的位后，我看着标签上更高的部分，是等价物吗，高位，不管那是什么，如果符合的话，我拿到了，如果它不在那里，它不是直接的地图是关键，顺便说一句，我不知道去哪里找，一百，还有你的生活。

你怎么知道的，嗯，这不是我做什么，函数是与FIB的类比，问题是，我怎么知道是二百二十二，它是我，我真的盲目地，我把我的，我瞎了，当它过去的时候，我盲目地去，我说，我去看看，十张二十二张地图的索引。

以确定现金的大小，我有什么争吵，我已经让我去字节，我准备好抓住那个字节了，但首先我们要检查标签，标签留下了，它不在那里，就是这里，所以我去萨克拉门托，我把它放在同一个广场上，然后我设置标签什么的。

等价的标签就在那里，现在我知道最后一次我会拥有它，这不是，我怎么知道，就在那里，它只是机械地做，没有，没有“如果”，唯一的“如果”是标签匹配，现在这是他们中唯一的，但它生活的地方还不够。

然后它生活在正方形中，我们都确定它是唯一的正方形，十个和九个将永远活一百万次，当我们在1099请求数据时，它必须住在同一个地方，那是直接的地图缓存，所以它住在哪里从来都不是一个问题，总是同一个地方。

唯一的问题是，标签匹配不匹配，它是从那个还是另一个，另一种颜色与他们检查标签的时间相同，以确保它是有问题的，告诉我名字，乔纳森·戈夫，所以说，书面发生的事情，因为可能会有点好笑，如果我改变它。

我在缓存和内存中是否发生了变化，或者只在缓存中，但是啊，所以我们今天不碰那个，但这就是为什么我一开始就说，这是阅读，阅读是一个简单的例子，只读数据，这就是我所做的一切，好啦，原因是，如果标签是错的。

然后，我要踢出整个街区，把我的街区从10点到9点，如果那是改变了的数据呢，这是非常微妙的事情，我们下次再谈，但我现在可以了，因为它不是，我只是踢出我的意思是，如果它不在那里，你看，这是一个小姐。

我得去萨克拉门托，我一个半小时后回来，好啦，给我萨克拉门托，我是开玩笑的，我们可以从萨克拉门托得到数据，我要去，不管那里有什么，我只是把它扔掉，我和萨克拉门托街区的十天组织合作，但这不是圣礼。

上交的实际数据，整片，我把它塞进去，我刚刚抛弃了另一个人，那是关键，我能做到这一点，因为光是读它，如果它在写。

会更复杂，好啦，问得好，但很好，很好的问题，你要这么做，我喜欢最聪明的，花了这么多时间在幻灯片上，我很高兴能和你分享这个，这是一个像教你，我没机会教花车是怎么工作的，我喜欢教书。

但这就像我教这些打开你的眼睛，这是如何工作的，以及如何真正理解，如何对待那些字节，这些片段，理解这些片段，这是我的缓存，我之前换了位置，我把缓存放在右边，左边的记忆，我只是交换了这两个。

所以这是同样的想法和注意，我已经画了缓存，现金有一定宽度，你告诉我问题是，CIS的尺寸是多少，它有多宽，也就是块大小，有多少行，它是显示您的块数，它显示了那个矩形的形状，你明白了，顺便说一句。

现金设计师可以说，你知道的，我得到了我得到了一个千字节，一个Kibibyte把我的现金放进去，我把它弄得又高又瘦吗，不要弄得太宽，宽度的选择，是设计师的选择，你有一个旋钮，如果我只有一个Kib字节。

那是十分之十的二分之一是二十四，奇比，所以现在作为一个10比特，我可以拥有它，十个一个，一个接一个，二乘五，五乘二，你明白了，我可以让它不同方向的行时间，身高达到十，我告诉过你要画出和缓存一样宽的内存。

不管是什么，内存宽度被绘制为块大小，不管块的大小是多少，你这样画记忆，答应我，你总是这样，你会的，你会发现这些问题很容易，你这么做是为了什么，我看到人们画记忆就像一个四，四个被一个吉比，或者一个接一个。

也就是2比32，就像不不不，始终绘制与缓存相同宽度的内存，你会发现这很容易，你不能，更难，我是说你仍然可以做所有的问题，但这很难，如果你那样做，画出和那个一样的宽度，好啦，然后同样的捕获数。

我叫它们标签号，现在呢，是标签，零一二右，只要做盒子就行了，零一二，最大限度，你懂的，现在标签索引偏移T o Theo Dan叔叔Dan，开始了，如果都是零，真实记忆中的零在哪里，顺便说一句，在缓存中。

这张照片上的地方和那里是一样的，你在顶部得到所有的零，对呀，如果i增加一位，那住在哪里，偏移量大了一个，那么它在哪里，左边一个，左边的邻居，你得到了它像六六八，野兽的邻居，那是个笑话，好啦，开始了。

现在都是，所有的偏移量都是1，在哪儿？一直走到左边，在那排什么，第一排零分，你拿到了，这有道理吗，所以那个警官将是我们的里程表，它只是滑过顶部，我只是在同一个街区的顶部吃了一口不同的东西。

顶顶最多标签顶，缓存中最多的现金数和最上面的块，你现在明白了，看看会发生什么，就像在过去你有一台打字机，它会去冰，然后轮到你了，你得去下一条线，这就是这里发生的事情，现在下一个。

如果我在里程表上再开一英里，我的内存里程表现在必应偏移量回到零索引，合二为一，下一个地点在哪里，就在下面，看那个，就在下面，顺便说一句，你知道的，你只要确保这里安全，那个点和缓存中的点一模一样。

会是下一个倒下的，零第一块，最右边的字节，所以这个，这就像一面镜子，好啦，不管我在这里画什么，它是这里发生的事情的一面镜子，你一定要明白，说同样的话，现在一直在上升，现在指数去最大的指数，哦，我的天哪。

所有覆盖你在矩形中的位置的位都是1，你在照片上的什么位置，现在呢，你拿那个，你明白它是如何越过顶部的，但从右到左，我们得把声音弄得太大，直到你在下一个左下角，呃，哎呦，开始了，接下来会发生什么。

偏移量为零索引，转到零标记，去一个，你在哪里，然后下一个看，你只是在下一个，你只要坚持下去，就像这样，他不知道，那里有很多白线，一直都是这样，这就是它的意义所在，现在你终于要得到它了。

看着它是如何工作的有点酷，继续看这个动画，如果你有能力看幻灯片和动画，比印刷动词好，因为看到这个很酷，直到我找到所有的，那是我最后的记忆地址，山上的最后一个，他就是死胡同里的那个人，最后一个在那里。

那是哪里，左下角，在缓存的什么地方，同一地点，缓存的左下角也是，好啦，对此有什么问题吗，我真的很想，我花了这么多时间在这上面，让你有一种喜欢的感觉，了解比特在哪里以及我们如何做到这一点。

现在我给你一个问题，好像很容易，看着我走到这里，我画了这幅画，我画这两个，好像这样容易多了，当你有了这个心智模型，知道这些部分是如何工作的，好啦，对此有什么问题吗，我很高兴你成功了，亚当走，井尺寸。

记住这里总是2点32分，什么都没变，这是一个32位的地址空间，按内存空间二比三，多少多少缓存，有多少标签，我把那段记忆，一个缓存的大小是多少，二到三二，好啦，我们就说2到3 2，所以如果我有。

假设一个缓存是二的十，十块钱，我还剩22块，所以说，而不是有四个gibi内存地址，有多少缓存大小，我有二对二十二，因为缓存的大小是10位2-3-2-2-2，除以二等于二等于三除以二等于十，是二对二。

两个，所以我有四个，可能有四百万个缓存，大小缓存在那里，你知道的，像这样画容易，啊哈哈，我们总是一致的，这是个好问题，如果我们不一致呢？不，我们一定会成功的，2的倍数总是一条线，这是另一个关键点。

我们永远不会成为问题，其中任何行、高度或缓存大小的值都不是2的幂，这将是所有，就像，又不是说，噢四三或者现金有四十二，不不是四三，太疯狂了，两点七是多少？那是什么意思，这将是一个很好的。

很好的二的幂很容易，好啦，让我们谈谈一些转弯。

现在呢，给你五分钟，我花了很多时间在演示上，这是一个术语，好啦，我们说的是缓存命中，当它在那里，这是一个缓存命中，如果是失手，缓存里什么都没有，你得找回你的记忆，有时石膏里有错误的标签，我们要调用缓存。

小姐，块置换，把那家伙带出去，就这些，那不是什么新鲜事，但就这样，好啦，现在，这其实是一种乐趣，我加了这张幻灯片，也是，因为我意识到我的系统的同事们正在用词语来描述缓存的运行情况，我就像，太酷了。

我得教你六二，看看人们，所以他们用一种声音，你听起来很酷，如果你这样说，所以当你的缓存是空的，什么都没有，当你熟记的字典，斐波那契的例子是空的，什么都没有发生，什么都没有打，所以那叫冷，缓存现在是冷的。

当你充满了价值，你有点，你开始跳舞了，你得到了你的最佳状态，你把它装满了，热身了，那不是很有趣吗？当缓存工作良好时，天气很暖和，就像，你把它装满了，现在你有很多现金，你根本不去圣礼，萨克拉门托你喜欢谁。

这就像最后一次，你知道昨天的报纸吗？和手说话的萨克拉门托，因为我就在这里，天热的时候，当现金很热的时候，一直命中，我只是喜欢这种思考这很有趣的模式，这是一个有趣的思考方式，好啦，所以这里有更多的术语。

哦，我们开始了，这里有一点数学，好啦，点击率是多少，我想我们称之为命中率，很简单的词，我占总访问量的比例是多少，是我们的点击率，那是我的命中率，我的失误率是多少？你可能不知道如何得到，如果我给你命中率。

漏率是多少？这是一个率减去你们是好的，或者你看笔记，好了，现在，我可能会说如果，当我错过了，我去萨克拉门托花了多长时间，那叫罚球失误，有道理对，命中时间是，如果我有它在缓存中。

只要告诉我它在缓存里有多少时间，这是伟大的，好吧顺便说一句，这包括检查标签的额外工作，顺便说一句，命中时间包括标签检查，谢天谢地，黑包就是我的黑包，但我也把它一分为二，顺便说一句，我们在伯克利发明了。

就像，我想我发明了和形状，伯克利发明的美元符号，或者钱，跟现金有关，你已经看到了，用于指令缓存和数据缓存的iDoll符号和D Doll符号，那是伯克利的现金，你们两个，这是伯克利的想法，我喜欢它，好啦。

所以还有一件事，问题来了，我有一些标签，你们知道什么是哨兵，我听到哨兵这个词，就像一种特殊的价值，那不是价值，这是正常数据的一部分，您可以分配，你可以把东西重置到哨兵，我们的标签有哨兵值吗。

所以我事先知道，他们是否记得事情，把垃圾热起来对吧，垃圾内存的所有值，所以我的标签是垃圾，嗯，如果标记是垃圾会发生什么，但恰巧和你身上的标签吻合，明白这是个问题，我们不能那样，我们不能有标签，是随机值。

可能正好与，当我刚开始的第一天，早上六点第一个电话，这是一个垃圾值，不过，刚好和，它在缓存里，我把垃圾拿出来，太疯狂了，我们不能那样，所以我们所拥有的，如果我们没有哨兵值，但我不知道，因为我已经用光了。

旧例子的29位，我对那个没有特别的价值，我得有办法说，不要相信那个数字，因为我不能相信这个数字，我们今天玩得很开心，星期五，所以我有一个叫做有效位的东西，那个有效的部分说，我到底能不能相信标签。

如果有效的说，不要相信标签，这是无效的，连标签都不要看，因为我没有，我可能会开始，然后重置现金，我该怎么办，我对每一行的有效位做什么，由有效位表示每行的一个块，我必须做什么才能将我的有效设置为零。

七比一，有效权利为零，这是无效的，一个有效，所以要把它们都归零，所以重置我的现金，将它们全部重置为零，或者清空我的缓存，如果我在中间呢，我需要喜欢切换过程，没门，是啊，是啊，就像你是个电影演员。

我去网络浏览器，那个缓存是电影里的，我不能从网络浏览器中提取，从电影数据来看，我得重置我的缓存，我该怎么做，把每一行都归零，现在它是无效的，我想我不会去擦洗它，让我擦洗一下，擦洗一下，我在擦洗。

再给我一点，但是硼砂什么的要废了，我刚重新设置了开的零，有效位，把它弄得很酷，我就是这么说的，有效位，一个是有效的零，即使有一个与有效位匹配的有效位。

说你不能相信价值，太疯狂了，所以这就是它的价值，好啦，所以这是我的一天，啊，看这个十六岁，哦我的天啊，十六起亚，我来晚了，总是那么有趣，好啦，我们下次再做选择题，十六千字节，啊，让我们做吧，基比字节。

16个字节块，我们动作快点，十六千字节，还记得卡洛琳的事吗？她告诉过你，如何思考，如何看待Kibis和这个K60，但是有多少位16 Kib字节，我们可能没有把两个放在X上，我们对X Y做了。

我不认为我们做了x y，我不认为我们做了什么，我不认为我们做到了，是啊，是啊，我们必须这么做，好啦，十六基布是十四比特，Kib告诉我10和6，十六岁就是十四岁，四点了，所以是十四比特。

我得到了14个比特作为我的标签，十六块，十六块，我需要访问多少不同的位，16块中的哪个字节，十六字节，我十六岁，一次一个字节，对数基数，十六之二等于四，所以整件事是四个，二乘十四是面积，这里有四个。

二对四十六，行多少位，有多少块，我有十个，就像你，减去他们，一共14位这里是4位，六十四减四等于十，基比玫瑰，所以我有一个Kibi街区，所以为了看，答案就在这里，那是一个kibi，民间十，二十四右。

那是个基比，所以你从照片上就知道答案了，我刚把它们都重置为零，我现在已经抹去了，我可以开始了，我们现在可以开始了。

我可以滚，但我滚了，全都是零，我准备好跳过点击器了，哦，实际上不用它就跳过了，好啦，我们已经学习了直接映射缓存的操作，数据透明移动的机制，在内存层次结构的各个级别中，绑定的一组地址。

我知道怎么从地窖里拿，地址给了我一组候选人的索引，所有蓝色的或任何蓝色的，我检查了标签，以确保它是我来自的蓝色，我们以前也有过，好啦，我们要多玩这个，我需要把这两个加到x y上，下节课。

所以你知道怎么玩数字，和我一样快，好啦，人们周末过得很愉快，很高兴再次见到你们，我们星期一见。

P34：Lecture 26： Caches - MultiLevel - 这样好__ - BV1s7421T7XR

谢谢你，谢谢你，我的管理规则，禁止企业出口先进芯片，需要训练或运行中国最强大的人工智能算法，有一句名言，美国，同款中国AI技术是未来，我们和我们的盟友要去那里，你不能来，所以这不是战争。

但这不是一种友好的，让我们分享最佳实践，嘿，去年你发现了什么，让我们分享它不是那个，不会发生的，他们担心未来，所以这是对此的反应，只是试图实施贸易禁运，但基本上阻止了思想的自由交流，从字面上看。

材料的自由交换材料不仅仅是，嗯，不仅仅是今天的芯片，它是这里性能最高的芯片，你现在可以买一些完全不在桌子上的东西，但你连制造设备都没有，明天的筹码，所以这真的是一个有趣的谈话。

请务必观看一个自然的国家空间，请注意美中关系是怎样的，因为有点冷，现在有点冷，完全不是冷战，但它肯定不是一个温暖的，让我们拥抱一下那些，哦对了，呃，祝贺新首相，我相信英国，他们是那里的首相。

他们今早刚刚宣布，所以这也很令人兴奋，所以有一个全国性的新闻，并不是真正的建筑，但又一次，恭喜所有现在掌权的人，好啦，让我们在10点10分的时候提前20秒开始吧，女士们先生们，欢迎来到收银员，第三部分。

六十一，Z。

我们在这里，我们继续，我想确定你看过这张幻灯片。

我想这在之前的课程中被略过了，如果你玩缓存的时候，流畅地思考。

我说，哎呦，这是一个16千字节的缓存，你应该知道有多少位，即16 Kib字节，所以让我告诉你如何快速地做到这一点，这是一张XY的2号桌，我将用我的指针指向xy，x在这个表中，所以这是一件奇怪的事情。

X在这个表中，如果x为零，这没什么，如果x为1，这是一个Kibi空间，如果x是二，在梅空间里，希望记住这个gibi，美帝佩，什么事？佩XB齐·亚比，记住这句话，那是个好主意，嗯，你有任何类型的。

我想卡罗琳给你展示了一些你可以用的助记符，但你应该基本上记住这一个，这是伟大的，我想这是另一个需要记住的，因为这是两个数字中的一个，指数的力量，所以如果我说2到3 7，二三七，你应该先说，你去七号。

你总是先找对号码，因为七是一种系数，从某种意义上说，所以二二三七，我七岁，好的七一二八，我要说一二八，我说一二八，我的大脑在利用这段时间查什么，三就是这么一二八，当我慢慢地说，一二八。

让我们来看看什么什么，给我一个0到0之间的数字，我能做什么，顺便说一句，亚比之后是，呃，有些人我想加州大学在圣克鲁斯，认为亚比之后应该是海拉，变得很有趣，实际上，如果你谷歌一下这个，说一千个雅比是多少。

你得到了一个，上面写着海拉一号，海拉是个很有趣的东西，所以地狱是地狱是9，好啦，所以让我们开始吧，给我一个从1到99的数字开始，任何人，给我一个1到99的数字，有人有人喊一号，九十九去九十八。

九十八是二百五十六，海拉，那是九十年代，地狱，好啦，我再给我一个号码，快点，八十三，八十三就是八，我做对了吗，啊呀呀，Daryabby，有时我得到，我把Z和Y弄乱了，好啦，所以目标是现在就这么做。

如果我翻转它，如果我现在翻转它，如果我说有多少位解决2。5个胫骨咬伤，所以我的内存空间是2。5 Tib字节，你想要一个字节，每个字节的地址内存，我可以加载字节并存储字节，你用5个字节。

打那口井你需要多少钻头？两点五，比那更大的力量是什么，四是二，所以这是两个是一个，塔贝是四十岁，所以我要说，四个二位，四个二位换两个，五个字节，这听起来对吗？让我们一起做吧，所以2。5个标签咬。

所以Tabe将在40年代，那就是四十多了，两点五，二的下一次幂，大于，这是四个中的这个，所以是两个。

所以我数了4 2是对的，四个二位访问，2。5 tabb字节，好啦，所以这就是处理这个的方法，你通常从Y开始，这给了你系数，然后乘数，从某种意义上说，虎斑猫，雅比人，吉卜赛人，好啦。

很高兴能和你的朋友一起练习，在长途汽车旅行中做这件事是很好的，给你的朋友一些数字，或者逆转，你说的地方，要寻址多少位，你扔出一些大东西，哦你知道的，一百个，我们有一百个吉比井，一百是七。

因为一个28的原木底座，一口井中的两口，对数基数2，是原木底座的天花板，两百所以两百到六点左右，所以四舍五入的天花板是一个7，所以我要说，我说了什么，100吉比我说给我100吉比对吗，一百个吉比。

所以让我们吉比是，什么是gibi，也许是两个，给我三百三十一是七百三十七，好啦，原来你是这么做的，我要你练习这个，习惯这个，因为当我们开始玩独联体的时候，我说，嗯，现金，这是现金数额，这是你的现金。

突然间变得很快，好啦，这是我的比特数，好吧，用16个字节的现金，非常快的16个Kib字节，你应该去，哎呦，一共是1414位，好东西好的，记住这个，好啦，直接映射示例，我们在讨论直接地图缓存。

最简单的缓存，我们有，让我们做第一个直接地图示例，一定会很好玩的，我们一起做，希望我会停下来回答任何人的任何问题，当我们经历这16年，哦，我的天哪，16 Kib字节，多少位，十四，我们刚做了，好啦。

16GB现金，总共要访问14位，四个街区，四个单词块，我们的字在那里是四个字节，四个字节，那是四个字，每个字是四个字节，那是16个字节块，要索引多少位，什么方块，我在那个块中有什么字节。

16字节日志基数2 a 16是，你得动作快点，所以让我们回去，让我们在这里记住这个，它在哪里，我的十六岁呢？见，在座各位都记得，所以如果我十六岁，哎呦，有四个比特，我需要4位的偏移量来告诉我。

在那个街区的哪一口，好啦，这是你需要快速做的事情，所以你能算出，区域的宽度，我们只是做了这个区域，总面积，总面积是多少位，16 Kib字节，那是14位，那是我的领域，这是我的整体尺寸。

我的专栏宽度是多少，它有多宽，我们刚做了，在我的宽度中总共有16个字节，如果我画一幅画，但那，我不知道，如果我的人是这样，就继续看上面的东西，我就在这里画些画，我去拿支笔，让我想想是的，哎呦。

太感谢你了，是啊，是啊，是啊，是啊，他们以前有很大的粉笔，他们现在只有一支很小的粉笔，一半的时间你在里面拿起小巧克力，好啦，所以我做了一个长方形，我也不知道，这个长方形是什么，我要放大到我。

如果可以的话，但我知道这在我脑海中是十四位，我是十四比特，这是二对十四，好啦，所以我说了什么，四个单词块，所以我甚至可以做到，这是我的，这是我的四个字，是一二三四，每个字是四个字节。

这意味着宽度是16字节，是呀，16字节是多少位，二对四，二到十四，到四，这意味着有多少行，有多少块，我有，我记得这些，这是如何工作的，二到十四，除以二，四个减去指数，所以到十四个，十四减去四到十。

二的十分之一是多少，奇比，我有一个Kibi街区，这是你快速做这件事的方法，我们以前做过，我想上次我想我做了这样的问题，这是同样的数字，我们可以把灯关掉，我们无法感谢你，所以现在我们有了那个形状。

顺便说一句，我有，记得我一直告诉你，让我们绘制内存始终与缓存一样宽，这就像一次我不这样做，只是想让你知道，如果我列出所有不同的单词一直在加载浮动，花车是一个世界性的，所以我要给你看，内存中浮动的所有值。

这就是刚才我在画一个全世界的记忆，当我给你看一张光盘时是不同的，浮动不同，32位宽值，现在只需保持三个二但宽的值，好啦，所以现在我们说的是，哦，在我加载字节和存储字节之前，现在我说的是文字。

ABCD或四种不同的浮动，他们看这些地址，注意地址相差4个，然后我现在下去，一会儿在记忆中是，再过一会儿，很久以后，从81年开始，八八零一零，所有的十六进制都是i j k和l so，我要读四个地址。

十四一三四八十四，会发生什么，我们要经历的是，我有所谓的线索，顺便说一句，这叫做跟踪，我有这四个记忆请求的线索，到目前为止，我们只做阅读，只是要继续戳它，我们不是想在这里做权利，那很复杂。

只是为了看看发生了什么，这是我的四个地址，十四一三四八十四，我记得的第一件事就是丹叔叔丹叔叔，我和你把每个内存地址分成三个区域，标记t索引，我抵消了，那是你做的第一件事，都是机械的没什么，这些都不是。

我只是告诉你一个算法，一个非常简单的算法把它分成这些字段，标记索引和字节偏移量，当我们做这些的时候，你会注意到，这就是四个值，十四一三四八十四，注意到一些有趣的事情，首先呢，我看到了你可以在这里看到。

但是标签是一样的，让我们看看我的光标会是一样的，标签是一样的，是零，啊，不同标签，所以那会很有趣，我们来玩标签差异，在那里，这是我的索引，我的索引告诉我什么，谁能记得我的索引告诉我什么，Jania。

你有个主意，你现在举起手来，索引是我在哪一行，索引是我所在的行，偏移量是哪列，好啦，所以这就是我们做的对，顺便说一句，这里的总比特数，你能想出这是什么吗，这里有四个比特，猜猜我的宽度是多少。

这十块钱算我的身高，所以所有这些都使得试图与，我刚才在黑板上给你看的，好啦，试着让我们做吧，所以这是我的标签，它有16字节宽，或者当我在这里画的时候，这是我的缓存，它有四个字宽，这些是字节偏移量。

所以你看到的所有有字节的东西，偏移量为零，这是一个零字节，一二三，当我提到一个词时，我总是用最低的字节引用它，所以如果我想说到这个词，我要说零，这就是，我把光标拿回来，这就是如果我说零，这就是整个词。

我说四个，就是这个词，但这就像字节四乘六，五乘六乘七，但说到这个词，我会说四或零，顺便说一句，你还记得这个，每次你的词对齐，每次你的词对齐，你相信最低的文本数字将是零，四八或，零四八还是C好的。

所以一切都会是0-4-8-C好了开始吧，我们记得我们加了，因为我们没有哨兵标记，我们上次说过，已经是周末了，你忘了这个，没有哨兵，没有特别的标签，位模式，那是禁区，全部有效，所有可用的可能标记值，嗯。

那我怎么知道什么时候刷新这个，当我有垃圾的时候，因为一开始一切都是垃圾，作为垃圾的内存，但我将用这个来获得真实的数据，我不能把垃圾放在标签里，碰巧垃圾和我的标签匹配，哦，它匹配，我查到了。

我读了一些垃圾，我不想那样做，所以我加了一点有效的东西来告诉我，我能相信现金还是坚果，当它是一个，我可以信任它，所以是零，我不相信它，所以让我们通过，我做的第一件事就是重置，我刷新了我的缓存。

我的缓存现在是什么温度，天寒地冻，天寒地冻对吧，里面什么都没有，我不能用它来获得好的打击，一开始我什么都没吃，好的十四，我第一次读到，我要读十四，你要做的第一件事就是，做你的零碎。

我基本上画了一个小盒子，我画了一个有三个隔间的盒子，左索引上的标记上的标记和标记，在右偏移量上，我基本上是这样做的，这就是我们在上面所做的，把顶部降下来，我在每个问题上都是这么做的，现在这是算法。

我们要为很多案子做这件事，你要做的第一件事是看，你看中间那个，有点复杂，但是你看中间的那一行，我是在处理几楼的问题吗，在那栋大公寓楼里，我要去，街上有个聚会，公寓里有个派对，索引在哪里。

中间的告诉你我去哪排，所以说，是第一排，是一个，所以我去第一排，好吧好吧，在第二排，但从零开始，显然是对的，索引一，然后下一件事是什么，我检查，你真的喜欢想他们吗，我告诉你，你会怎么做。

你下一步会做什么，让我们一起想想，你下一步会做什么，检查标签听起来不错，检查偏移量听起来不错，还有什么比这更好的呢，检查有效位是否为施工中的整层楼，还是要开个派对，在那里，它适合居住，检查有效位。

是零井，我们要错过了，那将是一个失误，所以我从内存中加载数据，去萨克拉门托，一个半小时后见，我在萨克拉门托，我回来了，我把它装进去，随便啦，那四个字是，因为你看，我一次输入四个字，我在利用什么。

当我去学习一些邻近的值以及，什么样的地方，记住这个空间的单词，空间，空间区域设置，我在利用马上就去的机会，如果你去冰箱拿饮料，给我也买点东西，当你已经在记忆中，你在那里的时候去拿点东西，这才是重点。

所以抓取四个单词，把它们塞进这些单词里，可以编码任何东西，只是四个字，把它们塞到空间位置，我在利用，所以现在，接下来我做的是，我检查我的标签，我的标签看起来怎么样嘿，我刚刚装的比较吻合。

我从记忆中的那个区域加载的，它必须与，这是我第一次填写，标签为零，我的标签是零，顺便说一句，我不是，我其实不是在检查，我正在写，对不起，我是我是像，我其实是在写标签，我加载数据，然后我写标签。

我不检查标签，我在写标签，我画了一个零，这就是我现在得到的，我知道，因为我知道我从哪里得到的记忆，我知道我从记忆的标签部分得到了它，请记住，标记是缓存大小的计数，缓存大小，第一个缓存是零标记。

内存中的下一个完整缓存是，下一个完整的缓存是，这两种方法基本上是通过计算缓存大小来移动和计算内存，16 Kib字节，有多少这样的，啊，有多少不同的标签，世界上有多少不同的缓存，嗯，有十四比特的现金。

标签还剩多少，共计，还剩下什么，我得了18分，那么有多少，我们会有多少不同的标签，让我们做吧，是我的十八岁，让我们做得很快，十八二百五十，六千，基贝，好啦，这就是你想流利地说的事情，我看到一只手。

你有吗，是啊，是啊，请在，去吧，问得好，问题是它能走多远，我能再去拿点吗，答案是当我们谈论现金时，我是唯一，抢一个街区，那是你唯一的货币，但事情是这样的，你是缓存设计师，你可以让缓存变得又胖又瘦。

你知道胖和矮，或者你可以把它弄得又瘦又高，所以你有一个，如果我这么说，你只有14个零件可以玩，我有14个零件可以玩，你想做成十高四宽的吗？或者十一和三，你看我在做什么，或者十二和二看看我如何改变方面。

把这十四块从十四块中取出来，你给身高多少，你给多少宽度，他们只是把它们加起来，我只是加上出口，像四和十，我只是把它们加起来，所以你可以把它变成十一个，十二哦，一个非常热的，真的十二岁，只有两个，现在呢。

你只有一个字宽，你明白我的意思了，所以你可以控制，作为现金设计师，它的长宽比，所以这就是你得到好的地方，让我看看表演，我的意思是，看看使用这种电脑的人，周围有哪些应用，哎呦，这是一个特别的，只有游戏。

游戏在哪里做，这种方式，就他们如何访问内存而言，因此，我将自定义我的缓存，这样的话，你显然想让它尽可能笼统，但是您可以为您正在做的特定硬件进行定制，好的，好的，所以我在写我的标签嘣，这是我的零分。

我希望我能覆盖所有的幻灯片，现在我已经准备好了，现在我去抓住我想要的那个词，偏移量告诉我我想要哪个词，现在这个偏移量有一个4，我为什么不，为什么我只跳了一个，不应该，我已经跳过了四个，得到了D什么的。

超过了那个，我很困惑，帮我一下，帮我一下，是四对，那是一个零，这是一个四，为什么我只翻了一个，因为它是四个字节，然后是按字节计数，所以是四个字节，哪个是下一个词，那就是，好啦，只是为了确保我假装困惑。

我只是想确定你也有同样的困惑，我们澄清了，明白了吗，所以我爱我的B回话，B返回词，B，再快一点不行，其实更慢，因为我得去萨克拉门托，我不得不用我的现金做一些维护和簿记，其实更慢。

所以我实际上在那个特定的阅读上付了罚款，但也许我会也许我会受益，哪里是我的，我的小指呢？哦，也许我会受益，哪里是我的奥斯汀权力，挑剔，没人记得好吧，下一个一个C相同的算法，一个c除以我的三个字段。

我得到0 1和1 1 0 0，那是什么？那是我的C，最后一个文本值是我的偏移量，好啦，我再做的第一件事，算法，你看到的这个算法越多，你还记得，我做的第一件事就是去中间，检查我的索引。

派对在几楼派对在一楼，我喜欢一个人的派对，我只会穿，我昨天刚开了一个派对，那真的很有趣，接下来我要检查有效位，有一个，我们刚调到1，顺便说一下，我们写了一个，但当我填满它的时候，我设置了标签。

我还设置了有效位，正确，我没有提醒你，但我必须设置有效的，当然我们会把它设置成一个，所以这很好，标签标签匹配情况如何，标签匹配，我得到了我的D嘿，你猜我在萨克拉门托的时候，把abc和d的空间位置。

上次我想成为的人，这次我想，因为当你使用数组时就会发生这种情况，很有可能你会有一个邻居，你知道你在以某种数组从这里复制到这里，很酷吧，你把东西搬来搬去，你可能在逆转什么，我不知道你在做什么。

但不管重点是面部定位，很可能你会让你的邻居进入下一个嘣我的邻居，这是一个打击，人们不必去萨克拉门托，不不不不不，所有的交通，所有开车去萨克拉门托的人，今天不是我，今天不是我，谁对此感到兴奋，这是好东西。

好啦，对此有什么问题吗，所以那是一个成功，因为d是b的邻居，太棒了干得好，哦，我们开始了，三四，我们该怎么办，地址正合适，这是32位地址，三十四，那里有八个十六进制数字34是实际地址，嗯，三个字段索引。

三个，今天在不同楼层的各方，所以让我们去那一层楼，现在这个和我们第一次做的差不多，这是无效的，检查我的有效无效，嗯无效，所以我得去萨克拉门托，抓住这四个字，把它们塞在那里是无效的，我有东西，更改有效位。

更新标记，查看偏移量并返回您想要的值，现在偏移量是4，我的F和以前一样，和第一个很相似，好吧，问题是这是一样的，那是我们看到的第一件事，是啊，是啊，阿纳斯塔西娅，您从哪里获得值，我要去回忆。

我要去萨克拉门托，在右边的第一张幻灯片中，有一张记忆的照片，我要去萨克拉门托，不管那里有什么，我给你看，那些E F G和H是记忆中的东西，第一个像四个滑回来，我展示了一张记忆的照片，就像，就是这四个字。

只是加载这四个字，E f g和h在那个地方，是啊，是啊，不用担心，是呀，好啦，那么接下来呢，哦，我们开始了，八十四，接下来会很有趣，八十四使三个不同的领域，标签索引和偏移量，我的指数是多少，一个哦哦哦。

我喜欢一个，我刚刚在一个，两天前我参加了一个派对，前一天我不得不去，我喜欢地板的，让我们做吧，它是有效的，因为我会说我在用它工作，这里很好，我们去检查标签，我我是如此接近标签，没有匹配。

你不检查那个标签，你忽略了那个标签，你去偏移四，你要回到B，那不是住在地址的人，是什么，八百八十四什么的，不管那是什么，我不在那里，你得找到记忆的正确位置，缓存不能给你不同的值，只是让你更快。

希望这就是现金的全部，它让你更快，不应该改变你最终对你的程序所做的事情，如果我把每台电脑都有缓存，把它移除或放回原处，但这只是没有不同的价值观，相同的计算--只是更快或更慢。

缓存所做的只是让事情变得更快，体系结构是关于性能的，很多架构都是关于性能的，所以是雾，失手了，所以我用记忆中的东西替换了块，所以我得去萨克拉门托，对不起，看到大约一个半小时的轰隆声，去萨克拉门托。

坐那一排，把它塞进去，现在更新标签，标签是这样的，那个地址的标签，不是原来的标签，现在在未来，如果我有八十四或接近八十四的人，我会很棒的，好啦，返回j，现在开始，你自己做吧，我要保持安静。

现在这样怎么样，嗯，我只是随波逐流，啦啦啦不，你现在要做一些工作吗？读三十，顺便说一句，我甚至把它分成TIO给你，我有多好，然后读一个C去，会发生什么，顺便说一句，你可以回头看看会发生什么。

我会给你答案，不过，请便，花一分钟，让我们做吧，大家一起弹，你得读书，价值三十，你是做什么的，缓存中发生了什么，你是做什么的，别只把价值还给我，机制是什么，发生什么事了？是错过了吗，是热门吗。

你需要改变你的标签，你在挑一些有用的东西，好啦，让我们做吧，当你在努力的时候，你应该说的三件事，用你的方言来说，处理缓存应该是，这是价值，这是一个价值或错过与替换，这意味着它是错误的，因为标签不匹配。

我得做一个替换，所以只是错过了，因为街区那一排很冷，还是被替换错过了，在那里我从记忆的不同部分阅读，现在有点烦人，我得把它扔掉，多余的手，有人想要额外的施舍吗，你亲身经历过，一些额外的手。

这里有一些额外的，是的，是的，什么是错过和错过替换，替换的失误是当那里有数据的时候，我得把它换掉，在右边，我可能得做一些更花哨的事情来回信，或者做这样的事，一片空白，那只是意味着它是垃圾发生器。

所以到目前为止，这其中的区别，我们还没谈权利，但是在这个特殊的练习中，错过和错过替换之间的区别但很大的问题是，小姐只是说那是垃圾，我把它装满了，替换先生的意思是那里有什么东西，但它不匹配的东西。

我在检查标签吗，我没有得到答案，但我在检查一些东西，那排在右排，这就是替补先生的意思，到目前为止，一切都很好，好啦，我们准备好了，我看到人们大多抬起头来，不再写作了，我们一起来好吗，三十是热门。

为什么三十是一个热门，让我们试试，我们到这里来，三十是热门第三名，我们做的第一件事是什么，我们该怎么办，我的行右的第一个索引，什么是行，我做的下一件事是什么，我做的下一件事是有效的，检查标签，从零到零。

嘿打得漂亮，我做的最后一件事是什么，去我的偏移量，那是零，那么哪一个呢，我拿起E，这么好，那很成功，我拿到了E，顺便说一句，一个C怎么样，我们之前看到的一个C，如果你看到，记住。

我们以前在一次阅读中有一个1 C，那么我做的第一件事是什么，让我们一起做吧，索引，我在哪一排，聚会在几楼？那是一个，好啦，我做的下一件事是什么，这是有效的，接下来我要做的是什么检查标签零，让我们咀嚼。

我错过了替换的什么，我把那里的东西填了进去，我想它会是，我想那是abcd，我忘了那是什么，我想是一张CD，然后我做的最后一件事是什么，不是这个，那是零，那是零的偏移量，四的偏移量，八的偏移量，十二抵销。

那是十二分，所以我想我还一个D的样子，我做对了，我没有作弊，第一个是热门，E，下一个是有替代者的失误，是一个D，这节课你们要学的最重要的东西，不是那个愚蠢的算法，你先检查哪一个，最重要的是这些是阅读。

值必须等于内存值，它们是否被缓存，记住缓存只是让它更快，我们一起说，一旦你这么做了，呃，现金只是让它更快，那真的真的很重要，缓存从未改变，价值，只是让它更，只要优化一下，我们所做的就是优化，好啦。

当然好的，呃，哎呦，哎呦，哦男孩，在这里，我们去看看，我们在一个有软垫的房间里，幼儿园现在我们在一年级，我们现在要做的，就像操场上的硬边，你可以割破膝盖，这将是真实的，让我们现在现实点，好啦。

写入块大小和未命中，多字多字块直接地图缓存，它实际上是这样工作的，我们做得还不对，但我要给你看这张照片，所以这是我内存地址的图片，这是我的32位记忆地址，好看着，会发生什么，指数先入右后入。

这是我的十块钱，我们刚刚看到那排，这是我的排位，我的标签出来了，我的百分之十八的十八位，标签，我们谈到了二十五万六千基比，一千个不同的Kibi标签，是的，是的，它被检查是否与我要求的标签相等。

当它出来的时候，这是钥匙，有一个和哪个说它是一个命中，当且仅当标记匹配，还有什么是有效的嘣，看到那酷了吗，这就是那里，有我的命中与否，啊，有我的命中与否。

如果你有一个小灯或一些东西会在你的电脑上闪烁得很快，你可以看到光，哦击中耶，现在这种事，会发生什么，这四个词组成了一个多路复用器，什么规定了标记，我们回去吧，对了两个位，四件事，由标记指定的两位。

这里有什么规定，我们到这边来，它是块偏移量，这两个是字节偏移量，因为它换了一个，但我说的是所有装载浮子，我们现在讨论的是阅读花车，所以我只读花车，我不在乎下面的两个字节，因为它们总是0，零四八c。

你要求的每一个字都更好，是字对齐零四八C，所以这些都是零，别在意这里，另外两个部分是我想要的部分，我在这些街区中的哪一个，我想让这些词中的哪一个出现在街区里，那是上面的二乘二位，这两位指定了这些渣滓。

泥巴上写着，这些家伙中谁赢了，血就出来了，我的数据不是很好，对于一个16字节的字节来说，这有点酷，四个字，16字节块，同样的事情，我们画一幅画，这就是它的工作原理，真的有点酷。

我们在利用什么样的地方开始吧，哎呦，有一个小问题，我们在什么地方利用这个空间，手举高自豪，他的颞叶是谁？高高在上，两者都看到了，我在玩它，谁是一个谁是另一个不，这两个缓存，每个缓存都是时间局部性的。

当你有一个块大小，那是一个以上的元素，那是空间局部性，很容易回答的问题，每个缓存都是时态的，因为你还记得，每个收藏夹列表，即使你的手机，收藏夹，不是最喜欢的，最近，最近的每一个电话。

如果你只有其中一个是临时帐户，如果我最后打电话给某人，这是我最近的号码，即使我有他们中的一个空间说走，你什么时候去萨克拉门托，找几个邻居，你要去冰箱拿不止一样东西，所以两者都在这里，不是非此即彼。

一个问题，咬掉一套有什么意义，如果你总是加载一整块，字节偏移量，如果你抢了加载字节或存储字节，就是那样，您想要哪个字节，但对于这个，我只加载了四个字，但在某些时候。

有时您必须管理这些表单中实际使用的字节，我只是在展示如何阅读加载单词，在这一点上，我们只加载，我们没有储存任何东西，好吧，我们开始吧，现在的问题是，我们变得更复杂了，我们在正确的油井上做什么。

我们要怎么写，我只是在推，记得啊，从，谢谢你，谢谢你在网上找到，供我或商店加载，我一直做商店到现在，我将讨论如何将一些数据存储到内存中，我去藏两个，也许我该怎么办，I，有趣的是，你不记得这个了吗。

我认为缓存是我检查的第一件事，我把它放到缓存区然后穿过缓存区，还要确保内存已更新，所以直接通过意味着我两个都通过，我通过缓存进入内存，因为缓存更接近内存如果你记得图片，就像中央处理器，然后缓存和内存。

所以你通过它到较低的水平，所以直接通过意味着他们保持一致，他们总是始终如一，你把它推过去，但这也意味着，我得去回忆一下，我要去萨克拉门托，右后卫，说你知道吗，我只更新到现金。

你做这个记忆的那一刻是不一样的，也许我的意思是它可能有同样的价值，它已经在那里了，但可能现在内存与缓存不同步，现在我们有些问题，我们怎么知道它不同步，我们得记住它是不同步还是不同步，因此。

一个肮脏的部分是记忆，脏缓存是最近的一个，我刚给缓存写了信，如果马上回来，意思是现金是最近的，记忆很脏，像你知道的那样脏不干净，那不是最新的版本，这是旧版本，也许肮脏是正确的词，也许是更老的什么的。

但肮脏意味着不一致，当它们不一致时，发生的好事，它们可能会在很长一段时间内不一致，这就是右后卫的美妙之处，我不用去参加圣礼，我想尽量少去参加圣礼，所以我基本上我喜欢保持记忆肮脏。

我什么时候才能最终更新记忆，我在接球处来来回回，这就是我，这是我的，这是手势，就像你们中的那些做锅时间的人，这是手势，往返于缓存，没有结束到第一次，我圣礼，在我的类比之前就是这样，现在是这边，我不知道。

我不会去回忆，我什么时候得去回忆，当我运行完程序，在节目中做得很好，我只是退出并返回给用户，但我知道你要去哪里，但不知何故我受够了，当记住这是一个没有记忆不知道的值，我什么时候才能最终在这里记住它。

我们去给我，当那个街区被踢出去，整块置换，那是必须发生的时候，当我把它踢出去的时候，唯一有这个价值的人是这里的本地副本，那是我必须做的时候，所以我想阻止替换，我必须马上回去，问得好问得好，答得好。

顺便说一句，有一件事，如果你有一些输入和输出，像个键盘，或者进入他们的操作系统会刷新缓存，这意味着它会把它推到记忆中，因为I O可能会弄乱我的现金，这就是最后一行，说OS之前对猫脸红了。

我的意思是如果我有，啊，有人想接收密钥命令，我最好确保记忆是一致的，因为那个键命令可能需要内存，一种叫做记忆映射的东西，I，O，实际上它可能直接与内存连接，我们来谈谈表演技巧。

你能直接看到两者之间的表演吗，就像直接穿过去可能会更好，当右后卫可能更好的时候，你能想象一下，当这些中的每一个，我说二加一总是赢不了的原因，在某些情况下，穿过去比较好，一个马上就回来了。

可能也是因为如何构建硬件，也许添加一点肮脏的东西会更复杂，那就更复杂了，所以这有点难做，不仅仅是让它们不一致，但你可以想象很多阅读和写作，只是在追赶，救我，去萨克拉门托的那些旅行。

所以你可以经常看到想象一个案例，只是普通的案例，右后卫会更好，现在我们还没有谈到宽高比，你是缓存设计师，就像你有所有这些旋钮，你可以把所有这些很酷的旋钮，当你玩你的缓存时，一个旋钮是你的现金有多大。

这是显而易见的，你的现金有多大，把声音调大点，另一个是宽高比是多少，给定缓存的位数，又高又瘦和又胖又矮，我能成功吗，我的宽高比是多少，吴旭，你玩那个吗，这就是所谓的块大小，你为什么要把你的块大小。

因为行数显然只是，旧缓存的位，减去要匹配的行的宽度，宽度就是高度，所以多少行是一个因变量，那不是自变量，从这一点可以看出，如果我说，哎呦，有十四比特，如果我把这排宽4位，嗯，这里是十号，我把它做成十宽。

四高，你知道所有这些事情都是非常清楚地相互跟随的，那么更大的块大小有什么好处呢，如果你要去萨克拉门托，多拿点来，所以看起来如果越多越好，只要继续做得更大，你为什么不停下来，你为什么要把它做得尽可能宽。

块大小等于缓存大小，你有一排，这有道理吗，我们一会儿再谈这个，好啦，所以空间猫看，如果访问给定的单词，我们可能会进入附近的另一个，可能是邻居，也许是四路，也许八个，但出于某种原因，我只有四个字宽。

如果我的代码一直在想，第五幕开始，永远不会帮忙，也许让它记住另一个二的幂，也许可以得到八个宽，八个字宽，或许那样更好，事实上，对于那个应用程序来说，那会好得多，八点怎么样，就十六岁吧。

在某种程度上你得弄清楚，你什么时候停下来，所以说，存储程序的概念是，您可能会访问邻近的部分，存储程序的概念是程序和数据都在内存中，那是一家商店，程序概念说并不总是这样，程序曾经是，你会硬连线一些东西。

你真的硬电线什么的，然后在软件上运行数据，你只要，你知道插入一些数据，但它是为一个特定的问题而设置的，通用计算机大约是，让我们把程序和数据加载到同一个内存空间中，太神奇了，我们如何访问程序。

这一条指令缓存权，指示现金，这个，下一个是什么，下一个得到它PC加4，下一个，下一个，我正在线性访问它，它对空间局部性的尖叫是什么，我把整个街区都装进去，然后我有所有这些命中的邻居，哦，好吧。

猜猜有一个分支，前面三个后面三个，我已经上膛了，喜欢那个，数据怎么样，通常如何访问数组，你会随机戳一个数组，否，你流过它，你，你知道我等于一，你流过它，对空间局部性的线性尖叫，我刚好研究博弈论。

下一步就是一个随机的新位置，所以我在做你为缓存做的最糟糕的事情，这就像随机戳它的记忆，我就像走过游戏树，我不知道这个位置的孩子是什么，这是个新地方，我以前从没见过，记忆中的另一个地方。

根本不是那样联系的，现在有一些巧妙的优化，但那是最坏的情况，我随便戳，但大多数事情就像一系列线性扫过，我从这里抄到那里，这两个都在尖叫空间局部性，所以他们都希望你有更大的街区面积。

我说它很适合顺序数组访问，缺点较大，块大小意味着当我必须，当我错过了，可能是正常的错位或错位块置换，我得去萨克拉门托多花点时间，当你进去的时候，顺便说一下，当你去冰箱，去给我买薯片和薯片。

每顿饭也给我买，下周我要吃东西，就像等等什么，我从萨克拉门托回来，你看到他说了吗，那叫罚球失误，所以为什么不呢，这不是免费的，午餐，伙计们对，你造血，您的块大小，这对空间局部性很好，命中率可能会上升。

那太好了，但是一个更大的失误点球，当你错过了，好如果方块太少，你真的有这个案子，街区太少的地方，如果我从两个复制，假设我从数组的这一部分复制，再加上那部分军衔，把它放在数组的第三部分，最后有两行。

我不能把这三样东西换成现金，我不能从A和B复制，把它放在c中a加b等于c，我不能那么做，如果我只有两个地方，我可以从，我至少得有四个对吧，二四，所以这是个问题，当你的方块太少的时候。

所以让我们来看一个极端的例子，从字面上看，整个捕获是一个大洪水，就像煎饼一样，我做煎饼赚钱，世界上最大的煎饼，实际上是一排，偏移量的位数等于缓存的位数，我的索引零有多少位，因为我没有争吵，我有一排。

只是一排，我只是去那一排，它不是，我有选择，甚至不像我有一个或另一个，无行，顺便说一句，这是我的答案，圆周率是多少位，还记得我说过圆周率的第一个点击问题是多少位吗，永远，圆周率是多少位，像六十四无限。

如果我说什么，如果只有一件事，我的索引有多少位，如果我拥有一切，如果我真的，偏移量的位数等于缓存的位数，还剩多少，如果这是14，这是14，这里有多少位，二到零，我的索引有零位。

这就是为什么圆周率是零比特馅饼就在空气中，就像你呼吸和喝的东西，是啊，是啊，只有一排，二到零，所以索引没有位，你想吃点什么，不是说你什么都不能选吗，你得去那一排，一点都没有，一点都没有。

所以缓存中只有一个条目，如果项目访问良好，是啊，是啊，这是一个缓存时域，可能会再次被访问，但是是的，如果我从A复制到B怎么办，把它从缓存的这一部分复制到这一部分，如果他们碰巧不合身，我不能那么做。

正好是这个部分，在这里，到这里，内存中有不同的地方不起作用，因为我的行不够大，不能同时把这两个地方都放在内存中，这就是所谓的乒乓效应，或者我觉得每次都是错的，我从一个，A不在，放一排进去，B不在这里。

然后把B的行放进去，然后我转到井的这一部分的下一个值，那是B那是在那里面，只有一个人能拥有它，那是B现在，这是一个把它，太疯狂了，我会放一个进去，把它放在b井里b是b不，那是现在，把b放进去。

就像字面意思一样，每次都会错过，从A中复制一个非常简单的副本，然后把它放在B中，你只有一排，它们不合身，所以罚球失误与盖帽大小，那看起来像什么，你越想从萨克拉门托，处罚越多，很明显，好啦，那很容易。

这个速率与块大小的关系如何，嗯，我喜欢它，它是如何下降的，这是个很特别的地方，那个，我是真正的小姐，有多少失踪的井，如果我有你的邻居，我大概能做到，只是在最后它上升了，因为我曾经有两个。

你现在一路走到极限，我得到的太少了，我不能我有这种乒乓效应，所以它上升了一点，所以我会错过更多，一开始，它探索了空间局部性，就像我说的，最后一个暂时的卡利证明我没有足够的空间容纳，我想要的两样东西。

也可能是我在算法中所做的四件事，我没有足够的排来处理，四件事，从四个不同的地方访问四个内存，不管我在做什么，总平均数，下次我要给你们一个等式，但总体平均访问时间是这两者的函数，你最后像这样存钱。

你想要的是曲线上的膝盖，你可能没有听过这句话之前把这个写在膝盖上的曲线上，最低平均接入时间是多少，膝盖在哪里，你们中有多少人知道四十年前的戏剧，有一个著名的戏剧，我们也许可以在课堂上播放一段视频。

奶牛在最后几秒钟击败斯坦福的著名戏剧，在某种程度上，他们认为他们激怒了我们，但需求并没有落地，我们还在，他们声称膝盖撞到了地上，但在足球比赛中，他撞到了地上，球死了，我们在这里声称有必要这样做，看膝盖。

几乎不落地，那就像连接玩耍一样，这个膝盖不着地，曲线上的膝盖说，找到我的光标显示的地方，找到中间的块大小，如果把这两个因素都考虑进去的话，那就太好了，也许你有两个旋钮，一个旋钮是，但是缓存的总体大小是。

我们所说的第二个旋钮是块大小，所以把它调得恰到好处，所以你把膝盖放在曲线上才能得到最好的表现，挺酷的，又一次增加了点球失误，砰的一声击中了那个，误读了砰的一声，他们都上去了，很明显它会上升到那边。

失手有三种，让我们简单地谈谈它们，第一种叫做强制失手，这些强制性的错过是每个区域和记忆中的一个，你永远不会要求，每次你得到，你自找的，我从来没吃过，从来没上过膛，那是强制性的，你不可能绕过这一点。

做一个强制性的神秘主义者，因为以前从未见过，内存中的那个块以前从未被读取过，当缓存变冷时，这是一个强制性的失误，不包含任何数据，不能轻易避免，所以我们就不讨论这个了，内存中的每个块都会有一个强制错过。

我刚说了我又说了一遍，每个街区都有一个强制性的失误，你得记住，冲突失误是一种很好的失误，这是空的，如果我以前没做过，它是，这是一个强制性的错过，在强制小姐之前，我从来没有要求过那个街区，但我以前问过。

它不在那里，为什么不在那儿？这是因为一些其他标签在它应该在的空间里，如果是失手的话，因为另一个人在那一排，你说你以前问过，所以他以前住在那里，它过去常常去装货，居民，现在不是了，是井小姐，为什么是小姐。

因为标签不匹配，所以这就是所谓的冲突小姐，所以如果你追踪，每次你的第一次都是强制性的，之后呢，如果标签没有错过，这是不对的，这将是一场冲突，小姐，我们怎么处理，我们如何减少这种情况，记住我们是设计师。

我们怎么减少那口井，一个让演员阵容更大，那是一种办法，第二种方法是，也许我们可以有两个不同的街区，在同一区域，那个细节我们下次再谈，但如果不是记住，我们说它必须正好到这一排，它就不能排成一排吗？

也可能是下面的那个，像个邮箱，如果此邮箱已满，看看你下面的邮箱，或者一些很酷的东西能有这样的东西，那么这个极限是什么呢，一个完全关联的缓存说明了什么，如果我们能忘掉这一切，可能是盒子。

你知道你的邮件在这里，或者下面的邮件如果它真的可以去，任何地方，任何地方，任何地方，就像，这应该是件大事，任何地方如果我们去任何地方，我们称之为完全联想，所以有另一个旋钮，我现在想起来我告诉过你。

一个旋钮是缓存大小，第二旋钮为块大小，第三旋钮井，第三个旋钮就在后面，或者直接穿过，作为设计师的第四个旋钮是，你的联想能力有多强，直接地图就像，哦，你真的去了那一排，毫无疑问，完全联想的是你去任何地方。

可能在中间的某个地方，你只能去某个地区，我们下次再谈这个问题，好吧完全，所以你去任何地方，那是另一边，光谱的另一个头部是完全联想的，没有行，什么告诉你什么，我告诉你哪排了，你去，我是中间那个。

我们从中间开始，我没有我，如果你能去任何地方，没有我，团队中没有i，完全联想中也没有i，我瞎编的，让我们把它写下来，那很有趣，完全联想中的No i，缓存，这意味着我和所有的标签进行了比较。

你怎么知道它在不在，你得和每个人比较，他们不再吵架了，此缓存已满，我得到了一个新的，我从这里读到的，我读了一个街区，嗯，你知道吗，我要读这本书，已经到了吗，我不知道，检查每一个标签，看看它是否在那里。

对于一个3-2字节的块来说是完全关联的，并行比较所有标记，你得做，你得想想怎么做，福利，不再有冲突失误，这场冲突的整个想法都很烦人，好像只有一个地方可以去，不再有冲突失误，你得记住。

因为它可以去任何地方，什么导弹，我们将讨论下一张幻灯片，那有什么缺点，我要做一个比较器，检查硬件上的每一件事，那真的很难做到，谢谢你帮我找到这个，是的好的，第三种遗漏是完全关联缓存的遗漏。

如果你完全联想，强制神话的唯一原因，因为这是第一次，但在那之后，因为这里没有房间，如果你有更大的缓存，会成功的，但是因为我有一个有限大小的缓存，我没有地方放它，所以就是这样，容量错过是你看到的那种错过。

对于完全关联的缓存也是强制性的，所以这里有一个算法，让你自己先记住所有这些，我有一个痕迹，这是什么？我怎么给所有这些成功和失败贴上标签，通常它先错过了你的标签，考虑无限大小，全联想，像这样捕捉无限大小。

字面上无限的与内存相同的大小，无限尺寸，它发生的每一次失误都是强制性的失误，这意味着每个街区至少要有一个强制性的神话，就是这个意思，第二批，考虑我们想要检查的大小的有限侧缓存，那是完全联想的。

让我们假设我们可以去任何地方，这么说吧，我可以做一些奇迹比较器，让它发挥作用，你现在的每一次思念，那是一个容量小姐，将结合律从完全结合律改变为比完全结合律更小的结合律，我们要谈谈它叫什么。

一旦我做了那些，所有剩下的失手现在都被称为冲突失手，有道理，从逻辑上来说，好啦，我有时间问我的好问题，我太高兴了，三个问题，短信DDG二二，两个，三个，三三，或者去波列夫网站，斜线DDG，三个问题，说。

对于给定的缓存大小，较大的块大小比较小的块大小导致较低的命中率，如果您知道，通常可以使代码运行得更快，您的计算机的缓存大小和空间位置意味着，使最近的数据离处理器更近，各位请拿起电话，人们正在收拾行李。

请大家投票，在这里得到一些数字，我想我正在运行软件给人们，是啊，是啊，那里，很好，我的软件运行成功，我在看什么，好啦，让我们去投票吧，开始了，我们做得很好，我们做得很好，哦哦，我喜欢，好啦。

让我们讨论一下答案，一秒五九，我是完美的时机，哇塞，对这个讲座真的很满意，较大的块比较小的块会导致较低的命中率，较大的方块很好，但是你的意思是，答应了，乒乓效应，所以那是真的，你能让你的代码。

教授知道你抓到这个尺寸，哦是的，这是有史以来最大的真理，如果你知道你的缓存大小，您可以完全优化您的代码，所以中间是百分之百正确的，这是这三个问题中最重要的一个，如果你知道你的缓存大小。

您完全可以根据缓存大小进行优化，最后，在空间上，阿里的意思是靠近，保持左边，手段，保持最近的数据靠近处理器，否，那叫时间局部性，如此真真假假，我在找一个G做得很好的G，各位好吧，哦，天哪。

我们来总结一下，把你的标签分开，把你所有的记忆分成，T i和O去索引，那是你的排位，检查有效位，然后如果零加载块并将其设置为强制混乱，如果一个人检查标签，如果是失手，很受欢迎，如果是匹配的，很受欢迎。

如果不是，那就是冲突，错过加载标记中设置有效的块，使用偏移量返回正确的块，就是这张照片，就这样了，太感谢你了，乡亲们，我们星期三见，完美的时机。

P35：Discussion 9： Caches - 这样好__ - BV1s7421T7XR

下午好，欢迎大家参加今天的第九节讨论，我们将对危险进行一点回顾，工作表上有一节，这就带来了一点数据风险，其中有一点危险，这在上周的讨论中已经涉及到了，本周我们将从谈论现金开始。

这周我想在缓存上花很多时间，今天的讨论，所以一点点物流，今天要交第六份作业，区域贸易协定达成了共识，家庭作业6对项目3来说是很好的练习，嗯，有几个问题我们认为很有用，所以我们建议你做，嗯。

三八工程上周到期，项目3b将在大约两周半后交付，具体是11月9日，呃是的，正如我刚才提到的我们的议程，我们将快速回顾一下猫的危害，既然这似乎是一个我们可能需要更多时间的话题。

然后我今天确实想把很多时间集中在缓存上，尤其是，我们将讨论直接数学和关联缓存，如果你们不熟悉这些术语，今天我们将更详细地讨论这些条款，另一个资源，我想指出我们的助教，卡罗琳是缓存的超级粉丝。

她实际上教了相关的讲座，的，一些与现金有关的讲座，她专门为这个主题做了茱萸，所以我强烈建议你们去看看，如果你们想喜欢，再详细一点看，得到任何关于卡什结果的澄清，好啦，所以考虑到这一点，呃。

我们要进入数据危险，就像我们上周说的，可能有一天我们会有两个类似的指令，在我们有添加的地方，我挑逗X零五，然后SLI T零二零二，关于这两条指令，我们注意到的是，第二条指令的值。

第二条指令中使用的值取决于第一条指令的值，这意味着，这意味着如果我们要做简单的单次骑行，我们希望得到这些更新的值，然后继续进行，然而，如果您以某种方式使用流水线来实现它，有点不一样，因为请记住。

在我们的风险五数据路径管道的右后台，我们在这里把我们的值写回实际的文件中，但是，我们要确保我的指令解码阶段，也就是我们从重新文件中读取值的地方，我们要确保它与之前的指令同步，因为在这里。

我们有右后卫一直到这里，然后我们一路来到这里，然后我们有指令解码一直到这里，我们得想个办法，不知何故，就像防止一种一致性在，比如读取相同的值，在这种情况下，我们有两个主要的解决方案来解决数据危险。

哪些是数据转发，这就是鸡蛋，也就是执行，然后将执行阶段的结果传递到指令中，执行阶段在指令解码后立即进入，还是有摊位，我们要做的就是，呃，把我们所有的管道，所以说，右后台将在第二条指令的指令解码前进行。

对此有什么问题吗，你什么意思，喜欢喜欢你，以后再说吧，呃是的，所以我们在这里看到的，如果我们用这个普通的例子，这正是我们最理想的，我们希望它离开，好啦，我不知道做这件事的确切方法，但让我们看看我能不能。

好啦，呃，一秒钟，伙计们，好吧，看，目前我们有这样的东西，对吧，好啦，现在当我们谈论，呃，拖延几乎意味着我们必须把我们的东西像一个舞台一样向右移动，或者类似的东西，所以像这样的东西。

然后我们就假设这已经不存在了，如果我们需要再来一次，我们会把它再移动一个阶段，然后把这个去掉，这有道理吗，呃，我觉得，就像一些事情就像，就像运行相同的蒸汽多次与失速，喜欢什么我很好奇。

当这些什么都不做时会发生什么，或者生病，或重复同样的状态，所以，嗯，有一个概念叫做不做或不做，在那里基本上只有管道零，因此零将通过您的数据路径，就像一句谢谢，因为我只是一个讲座，上面说。

我想改变所有的指示，你基本上可以解决一个额外的周期，只要不做任何事情，比如不做一个循环，直到结果完成，然后你可以处理像，就像你做的一样，呃，复制，我会回到那个，是啊，是啊。

所以如果我们在这里放一条空白管道，咖啡还在吗，就像耶，就在这里，哦耶，把它拖下来，然后像这样向右移动，所以如果你说中间，然后所有这些都是零，那么本质上你在做同样的事情，你只是在一个零指令中流水线。

但我想他们展示的方式可以改变，就像整个指令的执行，是啊，是啊，所以当你这么做的时候，当你插入一个旋钮时，需要实际的下一条指令，我们感兴趣的那个也只是在时间上转移了，所以一切都无所谓，比如什么是过程。

就像你已经处理了分解和解码，没关系，就像那些东西发生了什么，这有道理吗，喜欢不对的，是啊，是啊，因为对于不对的人来说，你只意识到你需要一个不是，当你按下第二条指令，你已经，然后你在解码。

然后你需要从上一条指令到第一条指令的执行结果，因为它现在，使其进入执行阶段，哦对了，原来如此，嗯，你说的是，在这里进行数据转发，还是你只是在说拖延时间，哦不，两个都喜欢因为喜欢，好啦。

这是解决同一个问题的两种方法，所以我们可以将一个阶段的输出连接到另一个阶段的输入，在这种情况下，我们要把短路，或者我们可以输入一些空白指令，它只会延迟，也许是时钟滴答作响，嗯，隔间和旋钮不那么受欢迎。

因为它们确实如此，他们只是在浪费时间，可以这么说，嗯，但是数据转发更复杂，它需要更多的多路复用输入，更多的控制，但是是的，两种不同的解决方案，关于数据转发或数据危险的任何其他问题。

还有另一部分数据危险涉及内存，所以几乎，我们通常的情况是，我们必须在指令之前阅读dm，从同一寄存器读取，例如，如果我们有一个呃，从零开始加载字t零，然后我们要求和，然后我们必须使用t 0的值。

当我们把s一加到t零时，然后将该值存储为1，最终发生的是我们需要，不管是用什么方法，或者在这种情况下，我们可以为了记忆的终结，到这第二个指令的开始执行阶段，但请注意，这只适用于所有其他指令，是啊，是啊。

有一点评论，呃其实没有井，我们现在要去控制危险，所以差不多，我们可能会，在控制风险中通常发生的情况是，在我们这样做的情况下，不知何故需要拿一根树枝，我们有一些，假设我们有我们，假设我们有这样的指示。

我只是要去复制这个，这里，所以通常情况下，当我们发现我们的前任是什么时，我们会定义，我们是否需要在执行阶段分支，就在后面，因为它就在后面，重写执行阶段周围的。

因为我们可以决定我们的个人电脑所以从这里开始，但我们可能会注意到，有时是在使用流水线，最终的结果是，因为我们希望执行add i指令，就像马上上台之后开始指导，在b q的指令提取阶段之后，最后会发生什么。

我们有一些额外的，我们有一些值存储，我们将从，就像执行阶段或内存阶段关于或指令解码阶段，或执行有关添加指令的阶段，如果我们要给，我们得想办法把整个输油管，因为我们不想使用从数据指令中得到的任何值，相反。

我们希望从标签中的第一条指令中获取相应的值，所以这就是为什么我们需要以某种方式处理这个问题，因为我们不想处理无关的价值，为了喜欢这个介绍，我们要，我们的解决方案是要么拖延管道，所以呃。

我们可以确保我们所能确保的，一旦我们知道我们是否真的跳了起来，然后我们可以开始执行下一条指令的下一个状态，或者我们可以使用分支预测，它选择一个被接受或不被接受的猜测，如果我们错了，然后。

当我们使用这个分支预测预测器时，我们继续推进管道，我们假设，哦，分支预测器是正确的，所以它会选择下一条我们想要执行的指令，下一条输入到管道中的指令是设置指令，如果我们错了，我们只需要冲洗，那就更多了。

嗯，这样效率高多了，我知道这很让人困惑，但有人对此有什么问题吗？就像分支预测一样，嗯，老实说，我认为这就像是基于生产错误，就像假设我们不拿树枝，发生的事情也是如此，基本上你像烧烤一样处理。

然后开始处理添加i，最终登上了，呃，我想是执行的问题，它实际上是要被拿走的，所以在这种情况下，例如，会发生什么，嗯，我指导了半过程，可以这么说，因为在那段时间里你要上台，在我的ID阶段。

最后他们会去执行死刑，我相信为了烧烤，然后就会像，好啦，我们不应该拿这个树枝，让我们跳到下一件事，所以你的意思是我们，我们开始流水线化对应于无分支的指令，但如果我们真的拿走了树枝，现在我们有了这一半。

是啊，是啊，所以我们要做的就是，这叫同花顺，所以我们冲洗管道，基本上，我们只是停止执行该指令，因为我们不想忘记，你知道的，你的CPU现在必须处理，切换到标签并处理那个，有点时间延迟，但有时你是对的。

有时候你不是，总比等着好，但就像爸爸一样，是啊，是啊，是啊，是啊，实际范围预测，我是说，我们在这门课上并没有广泛地讨论它，但这仍是一个正在进行的研究领域，所以我不会太担心细节，但总体思路是对的，是啊。

是啊，问得好，还有其他问题吗？好啦，所以考虑到我们所说的，有一个特别的问题，在我真正想讨论的危险部分的第一部分，就像，两个相邻指令之间的数据危险需要多少个停顿，为了控制危险，我们需要拖延多少个惩罚周期。

所以我给你们两到三分钟来完成，好啦，呃，希望，呃，你们花了点时间，这个问题，有人想第一次分享他们的答案吗，第一个问题，两个相邻指令之间的数据危险需要多少个停顿，为什么你说，因为有五个阶段。

你想在写完之后开始你的指令解码，好啦，是啊，是啊，我认为你的想法是对的，你们很亲密，但不完全是这样，所以让我继续喜欢，呃，复制这个，所以，所以我现在这样做，这就像我们现在的管道。

你是说我们希望这一切发生，就像我们需要等到右后卫完成执行后，所以在很大程度上，嗯，呃，我们必须适当地移动这个，所以我的意思是，对不起，哦，我们走吧，好啦，所以如果我们把这个移动一次，呃。

我们还没到那一步，如果我们再来一次，我们还没到那一步，哎呦，哎呦，我们还没到那一步，要么，如果我们把它移到这里，我们将在右后卫之后进行指令解码，所以这已经足够好了，所以在这种情况下，我们只需要三个循环。

现在呢，四，这对每个人来说都有意义吗，有人想试试，嗯，控制危险问题，对于一个控制危险，我们需要解决多少个惩罚循环，这是一条管道，是啊，是啊，这是一条管道，是啊，是啊，有人想回答下一个问题吗？

我还有最后一个，哎呦，会是同样的三个吗，因为与其担心回到教学中，解码我们需要的东西，我们想做的是，等到最后，我们想拖延时间，以便执行结束，呃，执行结束有点像，还是对不起，在记忆阶段之后。

然后我们要在记忆阶段之后在这里做指令提取，因为一旦我们在记忆阶段结束后在这里执行，我们一定会知道，好啦，我们是否真的拿走了树枝，指令获取我们实际获得下一条指令的地方，所以你几乎是，会一样的。

只不过我们要，就像三个惩罚周期一样，只是我们会担心不同的阶段，是呀，是啊，是啊，对不起，你能回答第一个问题吗，第一个问题，好啦，当然，所以我们做了一个危险，我们知道，嗯是我们想要使用的实际值。

会被写回右后方的指令中，我们知道指令解码是我们得到这些值的地方，所以最初发生的事情是我们，我们的输油管是这样的，但是现在我们要确保我们的指令解码发生在写回之后，因为在右后卫，因为我们实际上是在写。

我们知道在指令解码状态下，我们知道在，我们知道，如果我们有我们的指令解码阶段，回信后，然后我们就会有正确的值，所以这只是一个转变，循环的两个三个指令，是呀，所以在这种情况下，它是第一条指令的右后方。

快乐的同时在国王的指导部分，是呀，好啦，是啊，是啊，你知道他们都有点，它们都涉及到数据路径的不同部分，所以他们不会喜欢冲突，是呀，因为我们在等一个男人，但不是马上回来，就是它是，那时我们就知道了。

就像在电脑上一样，你去哪里，是啊，是啊，差不多吧，更像是执行死刑，我们从哪里得到的，只是回忆过后，这有点像一种安全保证，你可以说，嗯，我想这就像被送回去，是啊，是啊，是啊，是啊，你能再解释一下吗。

为什么你要为控件解三个循环，好啦，所以这有点像他说的，所以请记住在我们的麦芽酒里当我们从ALU那里得到我们的东西后，然后我们要把它发回电脑，我们得把它送回电脑模组，因为我们已经计算了PC单元。

不管我们是去ALU指令中的计算地址还是下一条指令中的计算地址，P c加4，然后嗯，你只有真正喜欢才能，呃，只会写在下一个时钟滴答声中，就像实际价值一样，我们想要我们想要得到的指令的实际地址。

会写在下一个时钟滴答作响，所以我们必须在内存执行后等待，因为这就像执行后的一个时钟滴答声，所以这几乎涉及到，然后我们知道在指令中提取，我们实际上是从实际地址得到指令的，那是来自PC寄存器的，所以，呃。

我们要做的就是确保，我们的指令提取阶段是在记忆之后，因为那是在时钟滴答滴答之后，将值写入PC寄存器后，还有人对此有什么问题吗？我很想进入缓存，所以是的，如果你们还在纠结，我真的建议在办公时间来。

我们真的可以用它潜入深处，但是，考虑到这一点，嗯，我们可以从进入缓存开始，所以嗯，我们一开始为什么要使用缓存，目前我们的系统包括在这里有指令，所以让我们把加载词设为零，零，P，然后我们假设。

每次我们装货的时候，我们从我们的直接物理记忆中加载，但是，我们将在这里看到的一件事是，访问物理内存需要很长时间，最多一百，有时长达一百个循环，如果你想更进一步，就像进入电脑的实际磁盘。

可能需要更长的时间，大约一万个循环或更多，所以我们想要的，所以我们想要现金的原因是，我把它作为我们的中间人，因为从缓存中访问某些东西比从物理内存中访问某些东西更容易，所以这就是为什么我们。

我们想让事情变得更快，并使用缓存，取而代之的是，我喜欢想到的一个例子是，嗯，我不知道这有什么关系，你们会发现这个类比，但是嗯，假设你在热气球上，你和你所有的补给都在地上。

你能真正得到材料的唯一方法是通过一根电线，差不多要10分钟，如果你知道你会访问很多，很多材料，就像在一定的时间内，中间最好有一个类似盒子的东西，存储所有的值，你要保持访问权限，你要继续访问。

因为你不能拿着热气球里的东西，所以接下来会发生什么，你可以很容易地从盒子里取回物品，如果有什么，喜欢继续使用它，等等，等等，所以这有点像一种方式，我喜欢考虑缓存，因为它更容易检索和编写东西，是啊，嗯。

当我们谈论缓存时，我们交谈，我们想使用现金的两个主要原因与离得很近有关，这需要空间局部性和时间局部性，所以呃，缓存的一个好处是空间局部性，这意味着如果我们要访问彼此靠近的项目，在记忆中。

我们的缓存不知何故起作用了，所以我们也储存了附近的所有元素，所以每当我们需要取回附近的元素时，很容易就喜欢，进入我们的缓存并取回它，再到时间地点，呃，这有点触及，呃，热气球，我是我之前说过的一个例子。

但是假设我们需要多次访问某个项目，如果我们把它放在我们的缓存里，这让我们更容易保持，从缓存中访问某些内容，等等，等等，等等，时间地点，算是确保了，如果我们很快得到相同的元素，它会在我们的缓存里。

然后我们就可以把它找回来了，对此有什么问题吗，如果我们把我们的缓存纳入我们对计算机外观的总体概念中，它会是这样的，目前我们已经讨论了我们的处理器，其中包括控制我们的数据路径，然后我们的记忆就在这里。

储存了很多东西，不过，现在按顺序，如果我们想让事情更快，我们必须在这里包含一小部分内存，这将是我们的缓存，这就是我们喜欢的地方，检索和写入值，等等等等，关于缓存需要知道的一点是，它相对较小。

与内存大小相比，所以最终发生的是，我们可以，我们会在这里有一个巨大的记忆，但相反，我们只会储存少量，所以在这种情况下，呃，这里只有四个和四个数据项，与整个记忆相比，我相信这里有16个，是呀。

你可以控制像，缓存中有什么，是呀，呃，我们会很好的，是呀，呃，我们会做得更多，我们会做得更深入，是啊，是啊，所以给你们一点词汇，所以每当我们说话的时候，我们的缓存，在我开始之前，我会的。

我喜欢把它想象成一个双D数组，它以这样的顺序存储了一大堆块，所以每当我们使用单词缓存行或块时，我们指的只是一个，所以如果我们知道这整件事是一个缓存，我们知道我们的，我们知道区块只是指这些井中的一个。

它存储了一行数据，然后是一套，嗯意思是，呃，它将是一组缓存行，以形成一个更大的组，它是由索引索引的，当我们进入并设置这样和方式设置，联想和完全联想，我会多讲一点，把它想象成一组积木，你可以简单地在里面。

您只需要一个索引就可以访问，而不是两个索引，如果我们有两个街区，然后结合律是，再次形成集合所需的行数或块数，当我们谈到方式设置时，我会更深入地讨论这一点，联想和驱逐是当我们想从一个。

从缓存中删除猫的项的操作是什么时候，这通常是在我们想喜欢的时候做的，把一组新的数据放进去，或者替换当前的，当前缓存中的内容，所以我会继续为这个做一个新的页面，因为这将是一个很大的，好啦。

所以我们在这个班上，我们讨论了三种主要的缓存，我们有直接映射，我们将从我们最严格的一个开始，也就是直接地图，嗯，每当我们把索引分类到缓存中，我们只是假设每件商品一个街区，所以如果我们知道这是我们的索引。

这是我们的数据，我们知道这是我们的索引，这是我们的数据，我们我们有点像是非常严格的限制，其实我把这个，我们这里很严格，并确保在一个特定的索引上只能检索特定的数据，又不是说。

我们可以假设同样的指数也意味着，我们可以把这些数据读到no，我们不能那样做，我们必须非常严格地限制它，然后我们有了完全关联的缓存，现在，我们在这里使用的是，我们需要一个索引来实际访问某些数据。

如果我们根本不需要使用索引呢，就像找到，空的，缓存中的任何空白区域，然后把我们的数据放进去，这就是完全联想，如果我们有一个很简单的缓存，上面都是这样的数字，不一定受指数限制，我们可以检索到哪些数据。

如果我们想的话，我们得看看，如果我们知道，我们在缓存中寻找的标识符，那我们就得找遍所有的街区，因为任何块都有可能存储我们的数据，最后我们已经准备好了，联想，我们结合了，比如没有索引来访问不同类型的数据。

实际上对一些数据使用索引，我们把它组合在一起形成，所谓的n路集合在单向上的联想，我喜欢认为它是，假设我们有，这是我们的索引，而不是简单地存储一行，而不是每个索引存储一行内存，我们可以储存两个。

也许甚至三个，也许甚至四个，我们不是，嗯，这取决于n是什么，所以如果我们说我们是双向集合联想，这意味着每个索引只存储两行，所以一组由两个缓存块组成，如果我们有三个，这意味着每个索引将有三个缓存行。

如果我们有四个，每个索引有四条高速缓存线，等等，有人对此有什么问题吗，嗯，有点让人摸不着头脑，就像上次重组一样，但不是另外两个，您如何访问，我们有一个标识符，关于我们是什么，我们在找什么样的数据。

这需要我们仔细检查每一个街区，如果块在完全关联的，n路集合联想，我们确实有一个索引，所以一旦我们这样做了，所以一旦我们得到索引，然后我们有一个要查找的缓存块列表，或者N个街区去看。

然后我们会像标识符一样查看，就像，如果这些块中的任何一个有标识符，还有其他问题吗？是呀，呃，标识符是什么那是标记，是呀，我们会更深入地研究它，呃，当我们谈论高速缓存线的结构时，但是是的，是呀。

这是确定的指数，我想类似地说，就像直接，E，是呀，是啊，是啊，稍作修改，在我们不需要的情况下进行轻微的修改，就像每个块有一个索引，我们只是，我们可以在某种程度上缩短缓存压力中索引所需的位数，呃。

还有其他问题吗？我们是不是应该重温一下，因为我知道这些都是新话题，我想我们今天才开始讨论关联缓存，值得花点时间，是啊，是啊，好像你，你介意吗，如果我稍微剖析一下，所以说，顺便说一句，谢谢你这么做，是啊。

是啊，所以这些都是新的话题，所以最初你们听说过直接地图缓存，所以我们有这个TIO分解，对呀，我们有标签，索引和偏移量，嗯，假设我们试着先读取缓存中的一行，我们要看看我们的索引，对呀，所以我们的缓存。

所以它是由这些线条组成的，指数等于零，指数等于一，依此类推，因此每个缓存行都有自己的索引标识符，所以如果我们知道索引，我们很清楚该去哪里找，如果我们知道偏移量，你知道这里的缓存线。

地址中的每一位都映射到内存中的一个特定字节，对呀，所以偏移量会说，好啦，嗯，我这里有这个索引，所以让我们跳入，假设3的偏移量，我们将读取索引处的第三个字节，然后我们要比较标签，就像，好啦。

我们找到了索引，我们找到了偏移量，但这是高速缓存线吗，我们在找，是啊，是啊，呃，我在课上看到我们从右到左跳，呃，是呀，是呀，我的意思是，它是，嗯，已经提出了，呃，无数的方式，但丹的看法是，是嗯。

在同行地址方面，事实上我会的，我建议重温他的方法，因为他用地址的确切部分来谈论这些事情，就像呃，右边像地下室，不过分，是啊，是啊，因为当我们看到一个地址，我们有阿牛，你知道一些，在以下方面的抵消，就像。

块中的字节数将是最后几位，对吗，它会告诉我们我们要找的确切字节，但中间有一段，那就是说有点像，我们在看哪块数据，所以这个指数，这是我们的索引，这是我们的补偿，这个指数会增加，不管有多大，这些偏移位是。

我们会不断增加一个，直到索引被实际修改，意思是它是一块记忆，嗯所以是的，嗯，丹的意思是，这将是最不重要的，然后是下一个，所以这是同样的想法，我不想把你弄糊涂，我们说的是同一件事，问得好，虽然。

嗯所以用这个想法，就像这些标识符，这个标签，本索引，这个偏移，当我们谈论结合律时，我们要么只是说，例如，例如，假设我们在缓存中以某个索引加载一个块，对呀，说，指数为零。

但是我们想从内存中读取另一个具有相同索引的东西，嗯，我们不能用相同的索引在缓存中存储两个东西，所以我们缓存里原来的东西会被抹去，它将被新事物所取代，我们试图访问不匹配的标签，是啊，是啊，是啊，是啊。

所以标签不匹配，它是，这是正确的索引，但这是错误的记忆块，是啊，是啊，然后我们更新缓存，然而，联想说得很好，如果我们的索引可以正确地存储两个不同的东西呢，我们可能不匹配第一个标签。

但是我们可以在同一个索引中重新加载另一个块，并且两者都有，所以这就是他所说的时间地点，这就像我们还没有摆脱旧的块，我们还是要把它留在身边，但现在我们有两个指数相同的街区，所以我想的是。

我想多拿点你旁边的东西，在记忆的旁边，就像你会拿同样数量的额外东西，好像就在附近，说得好说得好，那是空间局部性，哦是的，嗯哦我是说，你的方向是对的，是啊，是啊，缓存确实是这样做的，每当我们把一块记忆。

我们像所有的街区一样，我们就像，如果我们说我们从一个地址开始，我们会继续抓住每一个，就像咬我们可以放进我们的街区，所以这有点像空间局部性，我们在说布兰迪说的是，假设我们访问的是完全不同的内存使用区。

那时我们需要一个不同的标签，因此，我们必须以某种方式将新数据放入缓存中，因为我们可能会在稍后访问，因为这就是本所说的，就像，你让整个街区都搬过去了，但仍然被保留着，然后你有一个新的号码，它有同样的。

或者这是相同的索引偏移量，让我们也把它放在那种与同一指数有关的东西上，但它不一定是相同的抵消，好啦，或者至少像嗯，你好像在说，你会保留旧的街区，也有一个新的街区，是啊，是啊，没错，这就像时间的位置。

是啊，是啊，是啊，是啊，是啊，是啊，这是一个想法，我们可以访问的东西，是啊，是啊，我们不喜欢只是把旧的东西扔掉，就像我们还能坚持住一样，再坚持一下，也用同样的索引加载新的东西，是啊，是啊，你真是。

这两者都有空间局部性和时间局部性，因为当你加载新的，挡住他们，当你也在周围的东西，周围也是，是啊，是啊，是啊，是啊，在这方面，但是，有时在这种情况下，我们必须牺牲块的大小，因为我们想提高我们的联想能力。

对呀，因此，我们希望增加可以用相同索引加载的块的数量，但也许有时这需要我们缩小块，嗯取决于你对缓存的规格，你能用它工作多大的尺寸，与，但是嗯，是啊，是啊，是啊，是啊，所以当你遇到问题时。

你会被告知你的街区大小是这样的，或者您的总缓存大小如下，这就是你的联想性，你知道你有多少块，这类事情，就像维度，各种各样的问题，我知道我们今天可能什么问题都解决不了，但我认为这可能是值得的。

只要确保我们把这些想法钉牢，是啊，是啊，这些缓存是本课程的一个重要核心主题，所以让我们来谈谈完全联想，所以我们就有了这个方块，但现在让我们说谁在乎指数是好的，假设我们有一个空缓存，我们想读取一大块内存。

我们把它扔在这里，然后我们要读取不同的内存块，我们在这里将标记与加载的内存进行比较，他们不匹配，所以我们就把它扔在它的正下方，就像你有一个空的空间，让我们扔一堆东西在那里，我们试图解决这个问题。

这里是说这个东西是满的对吧，我们读到一段记忆，我们需要做多少比较，是啊，是啊，你得比对缓存里的每个标签，你没有命令，您没有索引，告诉您要与缓存进行比较的确切内容，因此。

您必须将标记与缓存中的每个成员进行比较，而这里说嗯，你在看指数为零的东西，这里有一些数据，您只需将标记与索引零进行比较，如果不匹配，你交换，但现在我们得做个比较，比较，比较比较，所以我们用这个来交换。

这是完全联想的，我们用N方式关联来交换这个，我们要准确地说出尼基刚才说的话，我们有指数的地方是零，指数一指数二，但现在每个指数可以携带多个块，就这样结束了，是啊，是啊，是啊，是啊，是啊，是啊，是呀。

在这种情况下，这将是一个双向集关联缓存，所以现在如果我们读取索引为零的东西，并将其加载到缓存中，我们读到其他索引为零的东西，我们做了一个对比，然后我们把它装进去，我们不必和其他任何东西比较。

所以我说我们试着读一些指数为零的东西，我们做一个对比，然后我们就大功告成了，我们不需要担心指数一指数二，像那样的事，我记得这些，这些标记和索引索引只是内存地址的一部分，在您的内存地址中有某些位字段。

所以我们真正要做的是优化，不仅是空间局部性，时间地点，但我们需要做的比较，当我们试图读取和加载内存时，是啊，是啊，可能会完全关闭，但这更像是一张哈希图，有点相似，很像吧，就像是一种外部训练，我猜。

或者当你有很多事情，那其实是那，是啊，是啊，那绝对是一个很好的类比，就像你可以假设，嗯，每个人都喜欢这个数字，因为它是双向的，联想的，就像一个索引，已经，就像两个博客，有点像数组，是呀。

你绝对可以这么看，对不起，如果我完全喜欢被劫持，哦不不不不不，这很有趣，这些想法是不是更有道理，现在呢，我觉得最重要的是，在你的脑海中有这些不同缓存的图像，当你和他们打交道的时候，知道如何构造它们。

把他们引出来，然后像这样更新这个缓存表，当您为，我们让我们得到一些索引为零的项目，是否有某种边界，我们只是随便进来的，只要检查标签，只是通过所有索引零的值，是啊，是啊，没有命令，是啊，是啊。

你只需要检查攻击，是啊，是啊，还有其他问题吗？是呀，但这就像是被欺负的好处，呃，我想说的完全关联缓存的一个好处是，我们不受索引的限制，如果我们知道我们可以在缓存中存储任何类型的块，不管是什么索引。

这都比简单地有一个索引要好，如果我们知道我们会有同样的索引，在我们的直接映射缓存中，嗯，然后我们知道这将是一个不同的标签，每次都意味着我们要继续驱逐，继续增加，不断驱逐不断增加，最好有，在这种情况下。

最好有一个完全联想的东西，是啊，是啊，这实际上是他提出的一个很好的观点，我们会讨论驱逐政策，所有这些东西都来了，但这是你必须记住的，也是你喜欢的，而且完全联想，您只需要在缓存已满时驱逐某些内容。

而另一个不一定是这样，啊，我们有什么，好啦，嗯，我想我们几乎涵盖了很多关于标签，索引和偏移量，所以说，但是我们实际上是如何计算比特数的，我想快速讨论一下，所以标签就像，我是说某种唯一的标识符。

我们正在寻找我们的缓存，在这种情况下，它将是我们内存地址的第一个t msb位，如何计算标签所需的位数，就是，我们必须计算，我们必须知道我们的系统中有多少位，然后减去索引的位数，和偏移量的位数。

我们怎么办，我们如何找到索引的位数，嗯，差不多吧，呃，我们需要索引缓存的设置号和它可以，如果我们说的是，如果我们谈得很好，好啦，稍等一下，是啊，是啊，我们在索引中所做的是。

我们需要找到实际存储在缓存中的集合数，然后我们通过这些索引，所以在这种情况下，呃，如果我们讨论双向集合联想，嗯好吧，让我们假设二的相似幂的情况，假设我们这里有另一个索引，这里是二三，因为我们有四套。

即使我们有八个街区，我们只需要一个二位的索引，因为我们只是想通过四分钱，另一种思考的方式，您实际上可以将直接映射视为单向设置关联缓存，因为只有一套，每个块一个有意义的索引，是啊，是啊，然后偏移量依赖于。

几乎是缓存块中存储的实际数据的偏移量，这取决于块的大小，所以说，假设我们能够在每个块中存储大约16个字节，我们需要的是找到，得到偏移量的位数，我们需要计算出实际上有多少位可以获取每个字节的索引。

在这种情况下，这将是四个比特，因为16字节的4位，十六中的第二把锁是四把，然后标签得到实际的位数，呃，就像我之前说的我们，如果我们知道缓存地址是多少位，然后我们减去偏移量位和索引位的个数。

对此有什么问题吗，偏移量在这个，偏移量以字节为单位，是啊，是啊，哎呦，关键的事情，是呀，抵消，咬，Snupets，嗯，好啦，嗯，有很多不同的，嗯，事实上，我确实想谈谈驱逐政策，呃是，我不打算说太多。

我只想谈谈最重要的，它们是FIFO和最近使用最少的，以及LRU最近使用或访问最少的，所以FIFO，如果我们的布景里有一堆积木，我们知道他们在，所以如果我们知道我们有四个街区。

我们知道我们的订单会像B C D E，如果我们知道，如果我们加上这些，其实呢，让我们改变它，只是为了保持对B的一致更改，好啦，所以说，这么说吧，我们将在缓存中插入以下四种块，我们知道第一个是a然后是b。

然后我们有c，然后我们有d b已经在我们的缓存中了，所以我们不需要，呃加上任何东西，但之后我们必须将e添加到缓存中，因为我们的缓存已经满了，我们无法知道，嗯，实际上我会把这个改成嗯。

我们必须把第一次放进我们缓存的东西驱逐出去，如果我们使用FIFO驱逐政策，在本例中，我们添加的第一个块是，所以我们必须去掉它，加上e，现在假设我们想使用最近使用最少或最近访问最少的。

我们可以按照下面的顺序再做一次，B、C、D，然后我们有一个，所以这改变了我们访问的顺序，因为现在我们，如果我们被告知我们最近使用的，这就像d c b a。

但现在我们又进入了一个，我们必须改变我们的顺序，这样DCB就可以向下移动，然后A成为我们最近使用的，然后现在我们要排除一个方块来添加e，我们得看看我们最近用得最少的，在这种情况下，那是b不是a。

与国际足联相比，所以我们要做的就是去掉b块，然后加上e，这有道理吗，好啦，我觉得，呃，我们缺少，我们差不多按时完成了，所以呃，我想我们可以称之为，是啊，是啊，是啊，是啊，对不起，我们没有谈到现金的问题。

但我真的建议你要么看看，也许卡罗琳的区，或者嗯，也许再看看讲座，但当然是我喜欢的笔记，他们是，它们连在幻灯片上，你会得到更多的练习，写作业之类的，但是哦是的，家庭作业七。

P36：Lecture27： Caches - Set - associative,Performance with Caches - 这样好__ - BV1s7421T7XR

所有这些奇妙的刺激，所以八年，记录保持的时间越长，他说能有这样的经历真的很了不起，多年来记录再次被打破，你的问题是，告诉我你的名字，塔罗斯科，让它跑得更快，就像缩短，呃，所以问题是这样更好。

让时钟走得更快更难吗，或者是关键路径，他们没有重新接线，所以他们没有试图对关键路径做任何事情，他们只是在看，如果他们能保持冷静，那是我的理解，你只是把一个内置的系统，我不知道他们还想黑多少东西。

制造一台工作的计算机，这只是CPU本身，无论它只是一个小buff，就像罐子里的大脑，还是只是CPU，还是一台完整的电脑在工作，对我来说完全不清楚，我只知道他们需要做的是让这些事情奏效。

是有显著的冷却策略，像以前一样的粉丝，以前所有的CPU都是冷却的，风扇吹过散热器，他会想到像散热器，在转移时，大量的表面积风扇吹过，热力学中的热力学者，对传热了解很多，以及如何从系统中获得热量。

这是关于让液氮尽可能靠近你，到实际的核心，做实际工作核心，做实际的工作，令人兴奋的东西，我只想分享英特尔核心的这一新记录，8。8千兆赫，好好想想吧，我们到最后了，女士们先生们，欢迎来到现金的部分。

四个CX XZ吴很高兴你们都在这里，一如既往，这是本单元的最后一堂课，这些部队来势汹汹，顺便说一句，一旦我们完成了缓存，缓存总是在期末考试中，二十五年来我做的每一次期末考试，现金一直在那里。

大概25年前，缓存是我们在早期教的，这不像我们用的最新的尖牙，多年的渔获，确保你对基础知识有所了解，直接地图完全关联，我们今天学到了。

我们将学习一个叫做集合联想的新课题，所以这是一个强大的东西，这就是我的幻灯片，设置关联缓存，那是什么意思，我之前说过，有很多旋钮，缓存真的很有趣，我要到前面去，所以我可以在这里展示我的旋钮。

我得站在同一个地方，我上一堂课，当我做这件事的时候，上一课，我说，有很多旋钮，你是缓存设计师，你想让系统尽可能快，第一个旋钮是什么？缓存的大小，第二个旋钮是什么？长宽比是怎样的？又高又瘦还是胖。

你知道的，又肥又宽，你的街区面积是多少，这就是我要说的，块的大小是多少，所以缓存的总体大小，你的街区面积是多少，还有什么，到目前为止我们讨论过的另一个参数是什么，我们所有这些都是复习。

这是我们到目前为止讨论过的另一个参数，写政策很好，没人说对了什么，政策利好，你回信了吗，或者你写完，好啦，到目前为止，我们刚才说的最后一个是，你要去直接映射，每个内存地址都直接到邮箱插槽。

在那里它完全结合，是整个旋钮的另一边，你可以去任何地方，去任何地方，就像是，你知道的，很像飞机座位，你得到一张罚单，说这是你的座位，或者这是你的票，坐在任何地方或设置联想，这是头等舱的票。

坐在头等舱的任何地方，这是一张长途汽车票，坐在其中一个教练区，所以也许你应该去某个地方，但不是所有地方都是这样，所以说，另一个旋钮是你的，是同一个旋钮，去任何地方去一个地方直接映射，去任何地方完全联想。

在中间的某个地方，就是我们今天要讨论的，好啦，所以设定结合律，顺便说一句，记住咒语，队里没有我，没有我在完全如此缓存，原来联想有一个，我不得不说A是如此充分，如果社会演员阵容没有，我在那做什么不。

我的意思是，没有索引，索引告诉你去哪里，如果没有，我只要你去任何地方，所以没有。

我完全在这样的缓存中，好的，设置关联缓存，在你有标签之前它们是什么，索引和偏移量，和古老而间接的马，索引告诉你该去哪里，办公室前的标签和以前一样吗，唯一的问题是，是索引，当我转动旋钮时，当我转动旋钮。

伙计，当我转动旋钮的时候，旋钮是什么，的位数，我是那个直达地图怎么样，我和你一样大，因为你得去每一个地方，所以我是尽可能大的，你可以一直在这个大旋钮上，我是零，没有，我不我在完全如此缓存。

因为你可以去任何地方，我告诉你去哪里，如果你能去任何地方，为什么你会有一只眼睛，如果我把我做几块呢，这就是我们所说的，所以眼睛变了，取决于我们在做什么，那么有什么区别呢，这现在指向正确的行。

我们要把这叫做布景，所以哦，你的是什么？你的票是什么？说你说你会坐在头等舱的任何地方，商务舱的任何地方，在经济舱的任何地方，所以我告诉你在片场去哪里，我们叫它一套，我们不会叫它，这里的座位等级。

我们不喜欢那个词，好啦，有什么区别，每个集合包含多个块，就像你之前说的，头等舱有很多座位，你可以坐在那里，有道理，一旦我们找到了正确的布景，哦，这是舱口，一旦你找到了布景，你在哪里，你在片场里去哪里。

在这个集合中它是完全关联的，所以你去任何地方，我们可以谈谈你应该去哪里，所有这些事情我只是去空位，如果它在那里，但如果它们都满了，你把谁赶出去，所以这是一个对话，我们马上就有，那么现在是什么情况。

我们以前的缓存有多大，记住我的区域，还记得我的面积论点吗，缓存大小是多少，面积宽度，乘以高度，宽度是多少，一二三偏移，高度是多少？一二三块数，索引权，好啦，这就是所有的评论，但那已经是连续三堂课了。

又怎么了？

什么事？缓存的大小为，套数。

就像真实的数量，你们有头等舱商务教练时间吗，每组的块数，乘以块大小，每个块的字节，当你相乘的时候，每个现金得到字节。

所以现在它只是三件事的产物，好了，就是这样，这是很酷，你看，四字节缓存，在那里一切都是一个词，这只是一口宽，我们回到第一张照片，我给你看过，没有一个字宽和字节宽，上面有四个字节。

所有红色的都去上面的任何一个区域，那不是很整洁吗，所有绿色的都去绿色的区域，所以很简单，两套两套，四字节缓存，我现在暂停，任何有关的问题，有我们的第一个是最简单的可能，会发生什么，我们读一个字很好。

我们没有那种奇怪的，我们说的只是这张图片的字节，我们想让事情变得简单，只是读写字节，所以如果你穿绿色，你可以去那些绿色区域中的任何一个，如果你是红色的，你去找他们中的任何一个，你是怎么控制得那么好的。

记住你去任何地方，你可以去任何地方，你想去免费的，不要去忙的地方。

到前面去，如果他们都很忙呢，这就是谁做的对话，我们踢出去，我们一会儿再谈这个，所以基本的想法，缓存是直接映射的，你还有眼睛，你的我告诉你什么，你的票怎么说，我们回凉亭去吧，你的票怎么说，去哪一组。

头等舱套装，业务集，右教练组，每个集合都与，让我们再做一次算法，给定内存地址，我们该怎么办，好啦，我有一个内存地址，我该怎么办，把它分成丹叔叔，把它分成什么什么，哪些地区，什么，我欠了丹叔叔丹叔叔。

所以加入下一个，现在还留着，因为它不完全是Oche，不，我完全是一个OE，所以有一个我去我的眼睛，我告诉我哪个设置不是，我不再说阻挡了，哪个设置去一次，我在片场，我擅长什么，我要把所有的标签。

任何人无效，伟大的空地，我拿到了，但如果它们现在都有效，我得决定该怎么做才能把别人赶出去，好吧比较一下标签，所有的标签，如果匹配，啊，我现在在看书，我在读书，我正在找，我在找，我有内存地址。

在我的缓存里吗，我不知道，我得到了正确的设置索引，这是正确的一套，我这里有两个人，我有两个红色的，所以让我们做的图片，两个红色，是这个吗检查标签，不，是这个吗？是呀，是喔，是这两个地方之一。

但我必须平行地做这件事，我不能去，我不能按顺序做，我们说的是一个硬件，这必须是平行的，又不是说，啊，你为循环，你所有的软件人都去做一个循环，因为没有，我可以看到这个硬件必须是并行的，如果发生匹配。

请命中，否则，您将使用偏移量字段，当，如果有其他错误，如果是失手，把它放进去，希望有一个空位，把它放进去，然后用偏移量来做，就像我以前做的那样，没什么不同，唯一不同的是，这是一个两步的过程。

而不是它就在那里，就在这个地区，现在我必须平行地检查所有这些以确定哪一个。

它在这个集合中是完全关联的。

它有什么好的，我记得想象第一张照片，是啊，是啊，回去，想象第一张照片，记住，我们这里有四种颜色，就像红色，绿蓝绿色和橙色，我想如果我在两个区域阅读和写作呢，最上面一行的，嗯，我会错过像，我在这里看书。

但写信给那里，但它们都碰巧被读到了，我不能把它们放在同一个地方，因为两条红线都指向同一个地方，所以我不能同时复制一个数组，就像你知道的，第一个元素是什么？进一步复制，第二个元素把它放在第二个元素里。

我不能从两个地方复制，如果我只有一个地方，有点像乒乓球，我喜欢读这一个和好，那不是，做一个疯狂的标签，因为这里有标签，从这里阅读，写信给那里，从那里阅读，把它装进去，嗯，不同标签，好啦，把那个拿掉。

把这个放进去，从原点的另一个地方阅读，好吧，那就把它踢出去了，我在打乒乓球，我总是想念，我不再想念了，因为我从一个红色读到了那个红色，在记忆中随便挑两块，最坏的情况，它们都是一样的颜色，我可以穿我的钱。

所以这很棒，看图片，你看，我得到了两个红色，所以这真的很棒，比直接的地图缓存要好得多，顺便说一下，如果我问你，让我的直接地图缓存看起来很糟糕，你知道你怎么让它看起来很糟糕，做两个红色，对两个红色读写。

你每次都会失踪，可能有道理，对呀，因为你不能在照片里放两个红色，现在你可以放两个红色，所以现在那个堕落的案子，或者从两个方面快乐地阅读和写作，但他们碰巧是同一个直接的讨厌鬼，看，这是个问题。

现在你完全没事了，两个都可以，你在阅读和写作，整整一个街区，你喜欢它，所以这很棒，所以我们很喜欢，只是从，顺便说一下，你知道直达地图是单向的，数字方式是该缓存中的块数，如果我说一种方式，那是直接映射的。

有一张谈话的幻灯片，解释了好吧。

所以啊，有一个单行道，数字方式是一组中的块数，所以如果我走一条路，意思是这只是集合中的一个块，我回到了直接映射，原来是那个旋钮，我所说的直接映射的旋钮意味着单向，集合关联，完全联想是一种方式。

事情可以在一个街区里进行，这就是全部，这是整个缓存，所以那是一种方式，但现在我们说的是两种方式，我给你看的照片是双向的，布景中的两个街区，四路可能是那一套的四种颜色，等等，等等，总是二的幂，好啦。

这些只是特例，更一般的集合，同事们喜欢更一般的，我们基本上有一个硬编码，数字对一，然后我们想把它剪成n，现在我们说实际上可能是一个变量，现在我们可以把它变成2的任意次方，二四等。

开始了，哦，我喜欢这些照片，你就是这样把它连接在一起的，哦我的天啊，看看多酷啊，这是，这是我的地址，我有标签，我有索引吗，是呀，我有我总是有一个索引，除非它完全是一个社会，那我就没有索引了。

所以我有一个索引，这是我的索引，这是我的字节偏移量，事情就是这样，指数下降，平行向上，这是四路，在四个独立的平行缓存中查找，你从四个独立的平行缓存中离开，理论上他们每个人都拿着一个红色的，我查了索引。

然后平行地我检查这是否和以前一样，我们上次看到这个，检查标记是否匹配，有效位是否在那一小段代码上。

我来演示一下这是个大密码，就在这里，这是后面的圆圈，这和我们上次看到的标签完全一样，有平等平等测试仪，这是一个和，它是有效的。

如果是这样，它是一个打击，很受欢迎，如果它是一个或任何这些是命中，我有四个平行的比较器。

如果是命中，但现在问题来了，那我怎么做，顺便说一句，如果他们中的一个很受欢迎，理论上只有一个应该是成功的，我如何发送，哪个街区，那是在它是多路复用器之前，以信号线为指标，索引的一些位，现在呢。

我有什么好的，有趣的是，这条线上写着。

不管是不是成功，理论上，只有其中一个会同时被击中，所以我介绍了一个四A四对一的渣滓，就在这里。

这是数据值，这是数据，数据数据数据数据都下来了。

去一个四对一的多路复用器，通常一个四比一的马克思，我将有两条信号线，四件事，我选择两个比特来决定这四个人中谁赢，但这里我有四条平行线，每次只有一个是高的，因为他们中只有一个。

所以我们要介绍一个有趣的逻辑。

称为一热编码。

其中有四条信号线，四输入四信号线。

一次只有一个会很热，我向你保证这就像合同，当时只有一个热的，我向你保证在信号线上，然后如果第一个是热的，你从第一个数据中提取，第二个是热的，从第二个数据中，三分之一数据，四分之一数据。

这基本上是你的分数，就像一个最大值，其中这个信号告诉你要从哪些数据中获取，你怎么发电报，什么会，这样做的逻辑是什么，记住原始MUX的逻辑，曾经是信号不是S是信号线，不是A或S和B。

记住我们以前就是这么做的，就像一个小小的决定，在a和b之间。

所以现在看看这个，假设这些信号线被称为，假设有一个光标。

我需要一个光标，A，假设信号线上的四个人。

我们要叫他们信号A，信号b，信号C，信号D，数据线是a b，C和d，那扇门的逻辑是什么，信号线a和a或信号线b和b，或者信号线c和c或者信号线d和d就像，如果你还记得我们是如何看待多路复用的逻辑的。

我们只有这些信号线，顺便说一句，这是每比特，把每一点加起来，你这样做三次两次，总共32个比特，好啦，所以一个热的说这四个信号中的一个会很高，它是什么，你只要得到相应的数据值。

神经集，这种作品真的很厉害，真的很整洁，很明显，你可以很容易地一起构建这个，我说好，那是什么，那个多路复用器是做什么的，如果他们中的两个人飞得很高，我不在乎，那不是合同，合同是，我只打算开它。

一个又一个，一个又一个，一切都会顺利的，如果发生其他事情。

我不在乎，用示例替换块之后会发生什么，那么现在让我们来谈谈我们的整块置换政策，谁做的，我踢出去，我去排队，你想去，你有没有见过飞机的人，你先坐下，你见过有人，哦等等，我的座位有人了。

他们有时会超额预订航班，人们很困惑，他们把空乘人员带来，他们都得弄清楚，这就是我们这里所拥有的，我得去读一个记忆的地方，它不在缓存里，标签不匹配，我得把它放在某个地方，但是已经满了，缓存已满。

我坐在哪里，我该怎么办，我该怎么处理那张直接地图，我们用直接地图做什么，那是我的座位，这是票，我应该坐在那里，把那个人赶出去，标签不匹配，他们老了，不能把他们弄出来，那很容易，全联想井。

你可以在任何地方写作，我们知道有一套，联想良好，我得走了，我首先索引到集合，那么我坐在头等舱的什么位置呢，我想找个地方，努力寻找空位，就是这个想法和设置联想，这里有个问题，如果我们有选择。

我们应该把传入块写在哪里，如果有一个有效的位，它是一个空行，有效位关闭表示空行，抓住空排，很明显什么，如果所有的值位都很高，所有的标签都不匹配，这就是问题所在，那么哪个区块被套现的规则是什么呢。

你在缓存里，你好像有段时间，就像社交媒体明星一样，它们在一段时间内是相关的，你知道你已经几个星期没发帖了，你从来没有，你被套现了，那不是很有趣吗？

他们从美国公众的意识中套现，有趣的权利，所以这里有一些块替换策略，哦我的天啊，有第五个旋钮，记住我给你的所有旋钮，这是第五个旋钮，我的替换政策是什么，记住你可以设计所有这些东西。

这真的是一个很大的创造力思考，为所需任务优化特定硬件，也可能这只是一个游戏工作站，所以看看所有的游戏工作流，代码对此做了什么优化，不管你在做什么，所以说，最明显的是什么块，上面有很多蜘蛛网。

好久没人碰过的方块是什么，你只能有五个，你知道，想象一下你得到了一个非常著名的影响者的近况，但你最近的来电名单上只有四个，这就是最近抓住的，所以你认识谁，全都满了，一个新的人真的很老。

他们在TikTok上跳舞什么的，跳什么舞？他们都有，他们玩得很开心，夏日趣味舞，我得补充一点，我得加上这个新的性感的人，但我有四个人已经在我的名单上了，谁被赶出去，你猜怎么着，谁已经不相关了。

谁还没有发帖，谁没有在全国范围内引起轰动，这就是lru的意思，鲁说，找到最老的那个，上面有蜘蛛网的那个，无下文，无员额，你在90年代的繁荣中很重要，你走得这么远，套现，它被访问，最近，好啦。

至少像最古老的一个时间地点，记住时间局部性是关于，如果只是今天的访问，很可能你在那之后很快就访问了它，但如果有什么东西很长时间没有被访问过呢，可能您的代码已经转移到代码的另一部分。

你不能再访问那个数组了，或者你不在那个指导区，不管是什么原因，你已经不在那个地区了，把他们弄出来，这太棒了，所以Pro是一个地方，好啦，双向集关联的con con，易于跟踪，你有一点。

这一点告诉你谁是最大的两个人，最古老的，没有，现在你现在，你年纪最大，现在你们两个稍微告诉你那东西很简单，你是如何跟踪订单的，现在你在跟踪，像窗户一样，他们甚至在你的屏幕上有很多窗口。

就像你把一个带到前面，不知何故，您的计算机跟踪窗口的顺序，就像你最好的朋友，因为现在你要搬家了，所以好吧，现在我摸这个，那是我最近的朋友，但现在我得把他们撞到前面，他们必须保持秩序。

所以如果我遵守我的四件事的命令，四阶乘是什么。

24你得记住这两个人中的哪一个。

我是来了解，编码这些东西的两个四个总顺序，你对这个阶乘说你想让我们有一些，我的天啊，因为我们说的是二的幂，二四八八阶乘你想开始玩吗没有，这就是为什么在硬件上真的很难，跟踪真的很难，所以双向前进。

即使向前也很复杂，我们可以再努力一点，还有别的选择吗？没有，反过来说呢？至少最近用得很好，不管谁先到先得，好吧忽略访问，你忘了访问权限，如果你先来，我只是很清楚地记录了这一点，很明显是你先来的。

你出局了还是随机的，让我们随便挑一个，实际上令人惊讶的是，有多好，现实生活中的随机行为，那样真的很有趣，有时候你很幸运，有时你不只是随机的，作品种类。

好啦，这里有一个例子，所以让我们举一个例子，这会有一点帮助，我们会做lru，因为U是最常见的，我们只有两个方向，所以两个方向超过一个位，我们跟踪哪一个是订单，所以这就是我们的线索。

记得我们说过记忆追踪吗，有时你会有记忆痕迹，你运行这个，我们谈过这个我们谈过，是一个，什么样的小姐，是一种能力吗，小姐是冲突吗，小姐是对的吗，所有不同的失误，所以我们开始了，零二，只是这些是内存地址。

这些数字实际上是记忆中的地址，零，这是第一个内存块2，用第二个，第三个关于点击量的问题，这是一个很好的考试问题，一个很棒的小测验给你，这个lru替换策略会有多少命中和多少未命中，在双向四字节缓存中。

好啦，所以这是我们之前的红色和绿色，所以这个看到了图片，这是我缓存中的四个字节，我要把它们画成这样，从它开始，就像一个地点，一和零只是为了，想起来有点难，但我这样画是为了让你看到布景所以现在。

如果我认为这样画的好处。

顺便说一句，这个集合是指向那个集合的索引点，哪一组像左和右。

好的，好的，所以思考的方式，而不是集合是分组和垂直，现在布景在左右水平的某个地方，所以我才那样做。

好吧，我们开始吧，哦二，哦一四，哦，二，三，四，五，三，五，四，这是我的事，好啦，这是我的，让我们一起做吧，所以有一个小动画幻灯片，所以我们会有一些动画幻灯片的乐趣，看这个作品，好啦，这是我的零点。

失手了，什么样的小姐，是谁成员，什么样的小姐，这个叫做，义务教育，你得接受，你得承受打击，每一个内存地址都会被强制错过，如果你有记忆，我说你从来没见过你得拿着，你得错过一次，好啦，顺便说一句，零失误。

你不会错过每一个地址，应该错过每一个街区，所以如果你逐块查看内存，如果那个街区以前从未见过，那一定是失手了，现在每一个情况都必须错过每一个街区，记住你的地址块，因为如果你的邻居，如果是一个宽阔的街区。

你让你的邻居，你得到了一个免费的打击，我是说每个街区，你怎么知道那是什么，你知道那很重要，所以我把它带到零盘，因为零就像集合的数字基本上是偶数还是奇数，把这个扔出去，好的，所以设置零，放入位置零，嘣。

那是我的，现在呢，包含数据零的，顺便说一句，这就是我给你看的，那是零，这并不意味着值为零，这意味着图片中的数据显示，这是地址，我说的是零点的数据会进入缓存，只要确保我不是，这是一张小小的婴儿小照片。

高速缓存的数据的数据是存储数据，而不是内存，所以零的数据，我现在只是在画零，但这是零的数据会生活在那个地方，我只是让你看看，这样你就不会糊涂了，然后我要做一个小标签，上面说lru钻头被设置为一号位置。

因为我刚刚碰到了那个场景的零点，因此，如果我在集合零中有另一个访问权限，放在右边，就是这么说的，只要确保我们清楚这里的标签是什么，好啦，下一个我只是把它复制下来，所以这是一种运行动画。

下两个二偶数或奇数，即使如此，它被设置为零，好啦，啊，我把它放在什么上，啊，伊茹告诉我，耶耶，我放在那里，我现在可以拿0和2，零的数据，两个在同一个地方，所以现在如果我把读数从0复制到2。

它们都在我的缓存里，他们不是在我的钱之前，好吧，因为我刚刚碰了两个，零是lru，到目前为止，我们只是把它复制下来，现在我又得了零，嘿嘿，这是个暗示，阿宇，我喜欢这种双向设置，Associcash，阿宇。

Lru必须搬家，我摸到了零点，我要把lru移到右边下一个拷贝，哦一个，哦，1是我的第一个奇数，得把它带到第一盘，同样的想法，确定Lub的位置，一开始四，哦，哦，我们来了四个，也是连设为零，但他们吃饱了。

那是第一次，我现在有一个冲突，顺便说一句，这是什么失手，这很重要，这是什么样的思念，这很难，冲突能力，或者第三种是什么，义务教育，这个是什么，我们以前从来没有读过四个，我们从来没有，你怎么会记得想象。

这是一个无限大小的缓存，全联想，无限大小缓存，四是无限大，所以不不不，不担心容量，全联想，不担心冲突，我数到四，我以前见过四个吗，否，那必须是强制性的，尽管它闻起来像，这是一个冲突，因为我穿不进去。

但在无限大的地方，全额连带现金，反正我也会错过的，必须是强制性的，所以每个指标都必须有一个强制性的，打了一个强制性的失误，每次，绝对不可能，即使是最好的情况，无限大，最好的情况是在那边。

在那边完全相关的最佳情况，四个还是不对，因为那是强制性的，是呀，Delanya，哦所以是的，我一般是怎么看的，我想你有点回到了第一条规则，我想我有一张幻灯片，它有一种算法来做到这一点。

你首先想到一个无限大的，全关联缓存，你去读的每一个街区，你第一次，必须是强制性的，所以你把所有的痕迹都标上，一旦你把它移除，然后你去下一个，然后你说，好啦，现在让我看看，如果它是有限的尺寸，全联想。

如此充分的联想，好啦，现在我错过了那个，所以我们往那边走，我们去重播吧，让我们重新开始我们的踪迹，我们将错过，有限尺寸，我所做的只是从无限到有限，但仍然完全联想，有什么变化只是大小，所以如果我错过了。

小姐，那是什么？那是一个容量小姐，因为如果我有更多的能力，我本来会一炮而红的，但是由于容量从无限到有限，那很成功，那是错过的容量，错过了剩下的都是冲突，你又失手了，不是为了，这不是强制性的。

因为你以前见过，如果它是无限的，我就不会很好地拥有它，所以在这种情况下，电容炎的想法现在消失了，我们是冲突，你就是这么做的，只是思考这个伟大问题的一种方式，好啦，我们继续走，我知道还有别的办法。

快走快走，是啊，是啊，一个快的，告诉我这个方块大小，你，啊，这是真的，是的，问题是，块大小如何发挥，这是怎样的思念，如果我调整它的一些参数，我会有一个不同的模式来追踪我的踪迹，完全正确，我不能提前。

好好告诉你，如果一个盒子我变大了，然后我会让所有的东西都从一种类型转换过来，我不能告诉你，取决于特定的痕迹，我可能对此有不同的看法，所以会影响到它，它会影响我的痕迹，我的标签，我所有的痕迹。

我有更多的命中或未命中，即使他们没打中，怀念什么味道，最后一次会影响到，因为我的钱少，适合固定缓存大小，你的意思是，如果我把它弄得更宽，如果我把它做得更宽更短，我会有这种方式命中，我会有命中。

我没有的地方，我以前也失手过，但你也会有失误，你以前有点击率的地方，因为方块比较少，所以它会影响痕迹和你，如何标记痕迹，但我不能提前预测，因为这取决于每个特定的痕迹，好啦，让我们继续好问题，很好的问题。

到目前为止，得到一个四四是一个强制性的失误，从没见过四个，把它带进来，谁得到，谁把lru拿出来，lru说那是最老的，那是一些蜘蛛网，LLA用蜘蛛网，啊，今天是万圣节，接下来，万圣节快乐。

对每个人来说都很早，不给糖就捣蛋，别忘了，所以你明白了，你可以把它拿出来，蜘蛛网男，蜘蛛网是两个，四个代替两个，现在你得给它贴上标签，那个零是有蜘蛛网的lru，好啦，你继续走，等等，等等。

下一个得零分的是什么？啊，很受欢迎，所以打，把lru钻头移过去，等等等等。

好啦，所以我想你可能可以自己做这件事，一起经营这件事，挺酷的，好啦，有一个现金模拟器，这是它的链接，你一定是装了一个现金模拟器，我实际上把这个精确的值，零二零二零一四零，如果你看不到。

也许我可以放大这个，在变焦上，这是如何工作的，看看这个，您输入了两组的缓存大小，你要用那个来代替吗，你可以玩替换策略，或者现金的不同方面，那不是很酷吗，输入十进制或十六进制，这个不管用。

因为这些都是一样的十进制和十六进制，这给你看一张图片，看看这个，这告诉你谁在里面，看0和4，一个是这个实际上是颜色代码，他们，你在开玩笑吧，多酷啊，这是结果看看这个，这是失手总数。

分类我们对它们的三种分类方式，以下是一些点击量，神秘之处在于命中率，多酷啊，这是我们的蓝色痕迹，你知道他们把什么列为四级冲突吗，整个建筑界都很困惑，想得很好，因为它试图找到一个位置，那里有零个和两个。

但没有，原来的报纸上说四个必须是强制性的，因为你以前没见过四个，怎么可能不是强制性的呢，所以这里有一点窃听器，我相信，我相信应该是，所以这是一个痕迹，这应该是强制性的，所以不要搞混了。

他们会喜欢所有的代码，做得很好，代码实际上是，我觉得做错了好吧，这是一个非常令人困惑的，就连建筑委员会，我们在这里面有一点，我可以向你展示所有从事建筑专业的教师的思路，他们是漫长的谈话。

我们最终都达成了协议，那是完全正确的。

这应该是强制性的，好啦，所以现在，让我们来谈谈性能，我二十分钟前，我想我能挺过去，最后我们有一个很好的选择题，等待你作为礼物，所以第一件事是，我们想弄清楚，我怎么会没事，让我们回到大局上来。

你是个现金设计师，你有所有这些旋钮，你可以控制。

目标是什么，架构中的目标是什么。

让事情更快，就像有人说的，谢谢你，让事情更快，所以你为特定的工作负载改变的所有旋钮，你要负责，使缓存尽可能快，那是什么意思，我们有一个非常明确的指标，您希望减少平均内存访问时间，去萨克拉门托有很多循环。

一个半小时，想用我们的现金减少，现金从未改变，你得到的价值。

我不告诉你，计算的作用，快点就好，就是这么回事，那是个大局观，那么你如何在所有这些旋钮中选择，你有这么多东西可以选择，这是这个的味道，这儿的那个旋钮好吗？你想象一个音乐设计师有四万个旋钮来做这件事。

这是性能模型，最小化，以平均内存访问时间为目标，不错的缩写，也就是命中时间加上罚失时间，漏检率，命中时间，他说无论哪种方式你都要付出代价才能拿到现金，不管你错过了还是击中了，你拿着现金，我们谈过了。

如果你击中它，你只要去缓存，如果你错过了，你进入内存，你得到缓存，不管怎样，你都得付钱，所以命中时间是，命中时间加罚球失误次数，漏率，所有这些都受到你选择的技术的影响，您选择的旋钮，以及程序行为。

就像我们说的，你想制造假象，这是我喜欢的幻觉，这是幻觉记忆层次结构，内存和最低区域一样大，但和最小的一样快就是那么酷，很酷的幻觉，所以我在想哇，你的意思是，我有四段记忆，二到三，以寄存器的速度。

二是四千兆字节的内存，是啊，是啊，就是这样的目标，我们想让你考虑一下，别担心，现金会解决的，给人一种你永远不会去萨克拉门托的错觉，很明显你有，但想想还是挺酷的，往那边走，让这个神奇的系统，我们如何改进。

糟糕的点球失误，这个点球很难。

这是我的照片，今天，一台3千兆赫的处理器要送到萨克拉门托，如果我是每个时钟周期的三分之一纳秒，对不起是的，每时钟周期新生的三分之一，80纳秒大约是200个时钟周期，我能做得更好吗，这是我给你看的。

这是在CAS的第一次讲座之前，我给你们看了这张照片，我们能不能，我们有一种神奇的东西让我们做得更好，我已经给你上了三堂四堂课了，关于如何解决这个问题的三堂三堂三堂四堂课，我们该怎么办。

我在里面放了一个缓存，现在我走了，有时缓存有它，现在从CPU的角度来看，我不知道这是抽象的界限，我不知道那里有什么，有人在造东西，不知何故它更快，有时我会去回忆，就像等待，它就在那里。

就像你有它就在那里，那很酷，这就是缓存的作用，但我告诉你，有时候缓存里没有，谁知道这个图片的一个强大的递归，我能做什么，如果我错过了，我叫它水平，一级现金，我该怎么办，今天在那个盒子里有第二笔现金。

任何事情，你都可以递归，现在可以递归了，二级不是二级，啊，我要去萨克拉门托不，您可以添加一个，让我们把，喜欢的第三级现金，就像一张网，就像一张安全网，我要表演高空钢丝，有一张小小的网，如果我掉下去。

有一张更大的网，你认为这是一个类比，我明白了，有一张更大的网，明白了吗，如果我掉出他们所有人，我去萨克拉门托。

在第二层。

两两现金。

这是我的照片，这是我的CPU缓存，有我的一级二级井，这就是CPU缓存的全部类别，一级，两级，三个缓存是这样的，每一关我们一起走，每一关都更大，每比特更便宜，更快或更慢。

慢下来整个树就像整个层次结构就像那样更高更快，每比特昂贵，小，我本来要给你看我电脑上的缓存配置，我可以查一下，我马上就去做。

让我们确保没有时间，我最后能做的，如果我有那个只是给你一些数字，大致上这是我的照片，让我们做一个在，我真的想确保我能挺过去，所以一个马特，这算不算，它被击中了，Lone命中，现在我没有顺便说一句。

我不能只说命中时间，我只说一次命中加上一次失误，我错过了一个点球，但是惩罚是什么呢，我得去萨克拉门托所有的时间不，我还有一张网，所以一升一罚不中等于，哎呀哎呀，我开得太快了，一二一错过点球是一二。

现在已经完成了，下面的网，看看时间是如何递归的，两次命中加上两次失误，我两次罚失点球，啊，顺便说一句，这也太，我想念我两个，我得去，我要去萨克拉门托，我可以在里面放三个，Cetera。

但如果我把这些放在一起。

我把蓝色换成了蓝色，对呀，看到蓝色，我换成了蓝色，我得到了什么，我很抱歉。

我得到这张照片，基本上就是这个地方，替换蓝色方程，在一个命中时间加上l，一个脱靶率乘以数量时取代这个方程，我两个命中时间，加上两次失误率乘以我两次失误点球。

让我们做题，让我们做一个简单的问题，一些简单的数字看看这个例子的感觉，嘿暂停，我们选号码是为了方便，仅供参考，命中时间是一个周期，那是典型的失手率，百分之五，那很好，我只漏掉了百分之五，那还不错。

我打了95%，我真的很擅长这个，呃哦，但是二十个哦，这很糟糕，20个循环错过点球，那是很多，那不是萨克拉门托，但那是阿拉米达还是什么，我不知道，马丁内斯的新片段是什么，大概二十个周期，阿门是什么，去吧。

不要看幻灯片上的答案，阿门是什么，漏率次数，错过点球，你能在脑子里做乘法吗，顺便说一下，这里有一个提示，五是二十分之一，对你们都有帮助，二十乘二十是一个二循环，那还不错，那还不错，我击中了它是一个。

平均来说，这是两个来吧，所以这很酷，我们喜欢我们的渔获，我们确实降低了我的平均内存访问时间，每次都是二十块，如果我没有这个陷阱，每次都是二十块，我要去，我每次都去马丁内斯。

那还不错，好啦，我们开始吧，我如何降低我的错过率，我不想错过，小姐很难，我不喜欢错过，我喜欢热门歌曲，点击率很高，是啊，是啊，表现良好，我可以让我的钱更大，好的，好的，那是有限度的。

第一级缓存的命中时间比周期时间短，这很好，这意味着l 1缓存基本上和时钟一样快，那太棒了，这意味着它在下一个时钟周期之前就已经准备好了，那太棒了，这意味着当它在缓存中时，就像有一个登记簿。

我基本上是去寄存器或去记忆，就像收银机一样快，我不必拖延这一切，这是真棒，因为我越来越大，缓存没有那么快，这只是现实，当你变得更大，你得弄清楚它们是什么，你得到的越大，他们身上有些东西。

你可以有充分的联想，放更多的地方去那里，或者至少去N路，关联到比直接映射更好的映射，所以直接地图很好，是一件简单的事情，但我们有很多失误，我们不一定有，所以只有两种方法比直接地图更好。

在许多情况下，并不总是，但在很多情况下，好啦，这里有一个典型的秤，它会显示我的电脑，但我会在最后给你看，如果我有时间，Lone是几十千字节，Kib字节，我们是2号基地不是10号基地，我应该是K。

我做了一个笔记，应该是K，我不是K，B，一个周期内数十个Kibibytes的命中时间，小姐率小，那很好，我们有很多，我们得到了很多点击在那里，因为时间的局部性，如果块大小大于一个空间位置。

所有这些都导致了巨大的命中率和反向的低命中率，L2和大约数百个Kibb字节击中时间几个时钟周期，一个不少于一个，但有几个还不错，小姐率十到二十，为什么脱靶率这么高，所以记住l1的失准率是l1的零头。

想念那也想念我两个，为什么这个小姐这么高，为什么百分之十二十相对比较高，那么为什么这么高，时间和空间的局部性意味着我把它们都抓住了，就像我一个真的很好得到这一切，你知道的，从数组的一部分复制到另一部分。

你有点，做一些简单的时空操作，你击中的是同一个区域，一旦你把这些都剪掉，你显然也在看指令四处走动，你并不总是只做射线的线性条带，但你知道你做了很多好事，每个人都得到了所有的好东西，就像街角的星巴克。

就像那让所有喝咖啡的人，街尾那个，他们没有所有人，但他们会找到一些想喝咖啡的人，但是那个角落的位置那是一个角落的办公室。

街角的星巴克，这是一个得到了很多好东西好吧，现在让我们来玩L2缓存，这实际上只是L 2缓存的数学问题，所有这些价值观加在一起，一次命中一次循环，我不是为你工作的，一失手率百分之五。

L两次命中时间是五个循环，记住我说过的少量循环，我两次失误是15次，哎呦，好啦，L 2是给YouTube上的人的，有人在走廊里大叫，我想让他们都保持一致，如果感觉你和我在一起，两罚不中两百秒。

也许关门错过点球是两百个循环，让我们算算，数学怎么说我错过了一个点球，循环记住命中时间，我两个命中时间，加上我两次错过率，离罚球点一五到两百是三十五，那是一次罚失点球。

那么现在的平均内存访问时间是多少呢？那是，我把所有的l2都打包到l1里了，现在呢，只是一个周期，加百分之五倍，三五，两百七十五圈，我们回去吧，那比两百好多了，它比，比四个小时好的两百块在哪里，好过五二。

所以两块七，五个循环现在很神奇，让我们看看这个。

如果没有左二，没有DL 2，让我们做同样的事情，只是治疗它，对不起，我两个对不起，你的房租到期了，你没付房租，我把你们两个带回去，对不起，把它放回去，把它还给薯条，薯条有两个，剩下的会发生什么。

那是同样的数字，一个周期百分之五的时间周期，11个循环，l 2将平均内存访问时间从11个改变，还是比以前好不了两百，比两百好，但还是很多，十一要等很多，十一只是等待，只是等待，直到它再次出现在吉他里。

到2。07，五大胜快四倍，真的很喜欢，耶耶，所以我喜欢我两个。

所以他们才加了，因为这个原因，他们把L三个都扯平了，让我们看看实际的CPU。

顺便说一句，这些幻灯片让我在这里结束，如果你有时间，谢谢你，这些幻灯片不会被测试，我们只是给你看一些计数，所以你可以把你的笔，把手放回去，别紧张，当我给你一次关于这件事的记忆之旅。

看看上面这个旧的CPU数据缓存，有哪些注意事项，数据高速缓存指令高速缓存偶像符号，D美元符号，他们已经把它放在系统上了，那很酷，令人兴奋的是，从外表上看，L2的标签在芯片上，但不是左二。

只是标签做标签比较没那么有趣，我们有地方放，让我们把标签放在L 2上，但是L2的实际数据，生活要大得多，住在别的地方不是很有趣吗，吊牌钻二号在那里，嗯，这里关于缓存还有什么有趣的地方。

中间有个缓存控制器，超级缩放器，你可以同时做三个指令，那很酷，我们谈到了超标量，意思是我可以同时做不止一件事，每条指令折叠，记住这一点，这样我就可以同时做三件事，我们喜欢我得到的指导，右上角的能量单位。

有一个存储单元来做大量的存储和一个浮点单元，所以理论上我可以同时做三件事，一个人在处理货物仓库，一个是处理整数计算，一个人在处理彩车，同时，下一个很酷，这是一个奔腾芯片上的指令和数据缓存，32千兆字节。

这里和这里。

这里还有什么有趣的，哦快看，优化为Opta供电的一兆字节功率。

这到底意味着什么功率优化，一共有两块钱，顺便说一句，当你看着CPU嗯，这不是示意图，喜欢喜欢照片，每当你看到什么，就像很多行和列，这可能是缓存，这东西很复杂，有很多电线和不同的形状。

但这看起来像一个很大的领域，就像天空中的一个大太阳，就像一个大的太阳能电池板，那些可能是缓存，可能是记忆，那是个L，那是一二，片上缓存，那很令人兴奋，哦伙计，我们正在讨论最近的事情。

这是英特尔核心的实际图片，我七，这是我的六个核心，我的每一个核心，让我们看看做，他们有一种区域，可能在看，有一个缓存，一，一，二，一，二，对，这一切可能会有一个渔获，在这些核心上共享了三个。

所以这真的很有趣，我们很快就会讲到的，当您有多个核心时会发生什么，还没教你，具有共享缓存的多个内核是很有趣的，所以这两个处理器在一个处理器上有两个核心，两人都独立工作，他们都共享一个缓存。

这是一种节省空间的有趣方法，但是l 1和l 2对每个课程都是独立的，好东西，好啦，我们有足够的时间，我好兴奋，我给你看看这个，我还向你展示了什么，我的电脑看起来像，让我们做吧，开始第27课。

双向集关联缓存的性能不能超过直接映射，Cache扔下挑战不能打败我在沙子里的谷仓，就在那里，问题二，n路集合关联缓存的最坏情况，是n个内存地址的重复模式，最近芯片的最终结果，L4在芯片上。

去你要去的地方，你是发短信给二二三三三还是你pov dot com，砍下GG并把你的选票放进去，我们有足够的时间，太厉害了，开始了，好好想想，我有多少，到目前为止，我有一票，人们能把你的手机拿出来吗。

对大家都好，投票就好了，是呀，对任何人，你投票了吗，我们在这里做得怎么样，很多很多自贸协定，顺便说一句，不要让屏幕，不要不要，不要被同龄人的压力所迷惑，顺便说一句，伙计们，请在即将到来的选举中投票。

不要让同龄人的压力影响投票，要么用心投票，和你一起投票真的觉得对，很容易，哎呦，每个人都在说，用这个吧，不，阅读规则，阅读阅读，提议，自己做决定，你是你自己的人，我们有很多FTF，但哦，F越来越强。

在外面，三足鼎立，在外面好吧，我想有个时间给你看，我在最后一张幻灯片中的幻灯片，所以让我们在这里做吧，让我们一起做，可以双向设置，关联现金副本，我是卡什的导演，这是下一张幻灯片，我把那个留到以后再说。

所以我们先救第一个，后面的高阶位，中间位，最坏的情况对N方式的最坏的情况对N方式的最坏的情况，意味着我的集合中的n个插槽是n个地址的重复模式，最坏的情况或最好的情况，那是最好的情况。

最好的情况是两件事嘣嘣嘣嘣，在繁荣繁荣和事情这是最好的情况，不是最坏的情况那是假的，那是最好的情况，L4在芯片上，现在你只是把它看作是一个共享的L 3，然后我把L4放在芯片上，所以L 4是另一回事。

如果他们有L四个，所以这是假的，落在较低的两位。

高的那个怎么样，让我们看看这里，我们准备好了，当然，我们去吧，考虑上一张幻灯片中的缓存，好啦，总容量为四字节的双向集关联缓存，也考虑一个直接的地图，一个块或一个直接的地图，所以你有四个斑点。

双向或直接地图，让我们做吧，哦二，啊，四，两个O和两个从未见过的强迫失误，哎呦，从没见过两个，如果你有，哎呦，很受欢迎，所以这很好，那是一样的，到目前为止，四个从未见过的四个，那是个失误，强制错过。

我们现在已经谈过了，你看这个，两边都是偶数，只有两个位置，所以看这个，O，2，O，4，踢出了两个，这也是不对的，现在和我在一起，看看这个，现在我有四个斑点，零一二三直接映射。

零二或错过零二或错过零四都是错过，踢出去，零二还在，两个有我的手指，两个在我的同一个地方，两个是命中，直接地图更好，那不是很迷人吗？直达地图比双向地图好，尽管我把这整个论点，哦，等等，两个人说这样更好。

我可以找到一个特别的线索让你的缓存看起来很糟糕。

这里有一个例子，那不是很有趣吗？我仍然是我最后一张幻灯片，也许如果我有一秒钟，我要给你看我的电脑，嘿嘿，我们详细讨论了缓存，有很多旋钮，看看旋钮，我有你在生活中看到的缓存。

看文件系统缓存网页缓存游戏数据库表ASS，软件记忆，我们一开始就说过了，其他人对缓存有很多想法，你在手机上回忆，那是个缓存，好吧，好主意，如果东西很贵，但我们想反复做，在缓存结果中执行一次，那都是记忆。

那正是用来记忆的课，所有的旋钮都是什么，看看这些疯子，现金规模，块大小，正确的政策关联性，整批更换政策，你有两个，你有第二层，捕捉什么是参数，你有第三层，捕捉什么是参数，它们可以是不同的，哦，我的天哪。

多有趣啊，一定是缓存，所有旋钮的设计师，并根据特定的工作量对其进行调整，使用性能模型在所有这些选项中进行选择，谁想快点看到我的电脑，让我们做它在这里，我们去。

我们出去吧，我要加上滑梯，我们在苹果下面讨论这个Mac，查看此系统报告，好啦，首先是2。5千兆焦耳。

好啦，六十四场演出到这里的很多地方，我去系统报告和我去，哦这里，它是哇哦，老兄，那是我的电脑，我的电脑，看看这个l 2缓存2 4 6千字节，多少比特，十八奇皮是一个，二十六是八，十八岁十六岁。

可能是第三字节，那是多少位？二十四个十六岁，两个买梅，十八岁至二十四岁，对呀，那不是很酷吗，总记忆只有六十四，给我好吧，就是这样，非常感谢，伙计们，这是卡修斯，我们星期五见。