UCB CS61c 组成原理中文笔记（六）
P37：Lecture 28： Flynn Taxonomy, SIMD - 这样好__ - BV1s7421T7XR
啊，谢谢你为我们录制，我们总是从新闻中的计算开始，你们中有多少人听说过，阿尔法的阿尔法是阿尔法，阿尔法零谁知道它是什么，所以有人想说什么，什么什么，什么是阿尔法去，是个棋手对吧。
就是那个神经网络棋手打败了一些职业棋手，而且很受欢迎，他们想一概而论，所以他们试图建立一个系统，在那里它不仅擅长下围棋，它很会玩，嗯，一般事物，也许对人类有好处，所以他们决定，所以零点是它的一个版本。
它和阿尔法零的更通用版本，他们决定看看它是否能治疗矩阵乘法，把矩阵乘法作为一个游戏的所有可能的方法，多矩阵乘法是线性系统的基础，我们使用的许多神经网络，所以他们所做的是，算法的效率有50年的记录。
把两个矩阵相乘，他们决定让阿尔法戈，把这当成他们试图竞争的游戏，它会学习策略或学习最好的，啊，在这里做这件事更好，这是在这里做的更好的事情，这是在这里做的更好的事情，所以他们得出的结论是。
他们在将两个矩阵相乘的效率方面打破了一项有五十年历史的记录，这位是日本名古屋大学的数学家，说这是一个非常惊人的结果，矩阵乘法在工程中无处不在，任何你想用数字解决的问题，您通常使用矩阵。
这是麻省理工学院的技术评论，说阿尔法零号打破了一项50年的记录，所以令人印象深刻的是，他们能够接受这一点，并概括这一点，想出一个更有效的方法来乘你的矩阵，挺酷的，所以这是好东西，我们开始吧。
我们正在讨论一个新的话题，我们关闭了缓存，我很高兴能给那个带你通过，缓存空间，那真的很有趣，希望人们对此感到满意，或者在讨论、办公时间和实验室里处理问题，对那种材料感到舒服，我们把这叫做软开放。
餐馆的软开放是指它不是真正开放的地方，你不是真的在宣传它，但你可以为人们服务，这样做，我们将把这称为一个叫做并行性的新主题的软开放，其中我们将试图描绘出，在接下来的几个片段中，我们将使用并行性。
所以今天这不是很多技术上的东西，它实际上是关于画一幅关于什么的画。
我们将使用并行性，所以欢迎来到61，C很高兴见到你们很高兴见到你们从上次开始一切都好，你上次看到的一个强大的想法是，如果你是一个现金设计师，你有很多旋钮，你可以控制很多，呃。
您可以使用调整缓存以获得最佳性能，谁记得，他们中的一些人，我是说，看着屏幕，其中一些是什么，第一名，缓存的大小，第二，捕获物的长宽比，是又高又瘦，是不是又宽又短，这真的是块大小，您的块大小是多少。
从萨克拉门托到缓存的内存来回传输的单位是什么，然后我们谈好了，那些都是阅读，我能要点别的吗，如果我有权利，如果我有权利，我得有个政策，我只在本地写入缓存吗，没有写完，也许在你身上流淌，一路走到记忆中。
如果我只是跑到缓存，让他们不同步，我们将称之为右后卫缓存，我们需要一个肮脏的一点，让我知道，当它们不同步时，然后我们讲了联想性，是吗？那个旋钮是什么？我们了解到如果联想，这是一种联想，如果n是1。
它是直接映射的，你只有一套，你可以去，你很清楚那是什么，那一套只有一样东西，如果它是n，n等于，的，缓存中的块数，它是完全联想的，你去他们中的一个只去一个地方，这就是每个人，我会坐在飞机上的任何地方。
全联想，请记住，在完全关联的缓存中没有i，没有索引，你只要去一个地方，你去做一件事，你用你的偏移量来计算，你要抢哪个专栏，你得弄清楚，如果标签匹配，当我替换一个块时，我有什么选择我的整块替换政策。
最近使用最少，FIFO随机，我还有第二层缓存吗，所有这些参数是什么，做，我有第三层缓存，所有这些参数，真的很精彩，非常非常丰富的空间供你决定，你可以为第一级和第二级制定一套完全不同的规则。
在第二层有一套不同的规则，三级，所有这些都是为了优化性能，对于您的机器将要做的工作负载，如果你要有一台只处理好游戏的机器，然后根据游戏要做的工作量优化你的现金，如果是别的事，那你想想，如果是通用的。
你必须有一个我们真正谈论过的广泛的粉碎，嗯，你如何优化这个，你如何有一个叫做规范的东西，规范int规范fp，有不同的规格，你可以使用不同类型的工作负载，这些工作负载是国际商定的，并使用。
很长一段时间以来，人们都试图作弊，并试图为特定的测试用例进行优化，就像其中一个测试用例是八皇后问题，你能把八个皇后放在一个棋盘上而没有一个吗，你知道控制其他人，所以这是一个非常简单的问题，你可以这么做。
一些人在优化代码，只为编译器中的八皇后问题。
一点都不酷，所以想想所有这些基准，它们被称为基准。
您可能用来优化代码的所有基准，所以那总是开着，所以你使用的是性能模型。
有了这些基准，试着优化你的代码-好吧。
我们要开始一个新的话题，这是柔软的开放，一个叫做平行的话题，如果你真的对缓存感到困惑，重置你的大脑，过来吧，在线加入我们，和我们一起上课，你可以在这里重新开始，这很好，这张照片你已经看过很多很多遍了。
左边有五种平行，我们现在已经见过很多了，这很酷，就像，哇塞，我很高兴每隔几周就能看到这张照片，我看到了理解它的画面，你知道右边的照片。
数据中心的顶部，有一台多核计算机，其中一个核心是功能块，执行单元，底部是今天的逻辑门，我们说的是并行数据，我们以前从来没有圈过那个盒子，这是我们第一次谈论它，你能用一个指令和一个广告吗，一次加四件事。
这就是今天的主题，4。你能不能一下子就把四件事加起来？现在作为一个程序员，你需要担心其中的多少。
嗯，到目前为止，硬件描述在这里。
作为一个程序员，你必须真正担心这一点，呃，是也不是，但主要是为你做的，平行。
平行或平行，所有这些事情都是平行进行的，你不用太担心那个。
这里有与流水线并行的指令。
而且是的，对组装工作方式有一些优化，这样你就不用摆摊了。
我很感激，但在大多数情况下，卡米洛会帮你处理这件事，所以我们担心你有一个管道系统。
这只是一种自动，你免费得到的，如果可以的话，如果你是建筑师。
你在建造它，你为它做了很多工作，但如果你只是在软件层面，真的不用担心，太多太多。
你以为我懂，希望我的编译能做正确的事情来优化，对于我的五级管道并行数据。
这真的是你第一次看到它，您必须明确地作为软件人员进行工作才能利用。
事实上，你可以有硬件，这可能会增加四件事。
好啦，我一定是按了按钮，所以这是我们第一次谈论它，你必须明确地考虑这一点，你得做些工作，然后优化您的代码，其他优化是免费的，唱得很好，你在做一些工作，现在我要问你，你应该赶紧跑过去，你有错误代码。
你有错误的C代码，您是否应该快速尝试优化它。
为了并行化，我是唐纳德·克努斯，图灵荣誉教授奖得主，斯坦福大学，他有一句很好的名言，我想让你知道，我想让你读这句话，并生活在这句话中，真正的程序员，真正的问题是程序员花了太多的时间担心效率。
这就像我只是设置在错误的地方，在错误的时间，过早优化是万恶之源，嗯，至少在编程方面做了大部分，上面说的是，你去做那个代码，并行使用多个核，使用四个浮点数ADS，立刻，你最好让你的代码工作。
不要开始添加这些功能，然后你就想不通了，是并行化之前的核心问题吗，还是你在并行化上遇到了麻烦，使您的代码完全工作可靠，在每个广告中一次添加一个两个数字，一旦完全调试完毕，然后进行优化以增加速度。
所以在你把它锁定之前不要开始，清码，好啦，那真的很重要，所以确保我添加了幻灯片，因为它不是甲板的一部分，我意识到你知道你不应该就这么跳进去。
你真的想确保你有一个好的工作代码，在我们再做一次之前。
只是一个柔软的开口，我要说，我谈到了这个关于弗林分类法的想法，所以这是我可能需要放大，因为这里的字体很小，这张桌子不错，嘿嘿，好啦，看那个，这是一个相当快的转变，我觉得像戴托纳，新电池，好啦。
我把这里放大，可以支持串行操作，那是一排排，你的软件可以是顺序的，就像你一直写的那样，你可以同时做多件事，那么让我们先做软件，所以软件想想Windows Vista，想象一下任何操作系统。
你同时在做上百件事，你知道你在展示这个，你在读老鼠，你在放电影，运行1。4万个程序，同时，所有这些窗户你想都不敢想，很明显，软件在左边并行，所以想想你在写一些C代码，你不知道如何分叉、连接和执行线程。
它只是一段C代码，它运行矩阵乘法，所以软件可能是两种不同的口味，很明显，OS正在同时做许多事情，它将是并发的，你只有一个c程序运行矩阵乘法，现在呢，想想硬件是如何工作的，也许二十年前，二十年前。
二十年前我们就有操作系统了，我们并没有真正考虑并行硬件，意思是你没有能力同时发生多种事情，在相同的硬件上，你有一个CPU，一根线，你一次只做一件事，如何运行并行软件，嗯，一种模式是分时。
你给大家一点时间，只是四处走动，给大家一点时间，如果你有很多孩子，你就这么做，你给一个孩子，你把他哄上床，你就像第二个最小的孩子，我们给他们读了一个故事，放在床上，你给大家一点时间。
所以你想象你的硬件可能是串行的，是老式的硬件，这是英特尔奔腾4，在我们真正考虑多核之前，简单的老派奔腾四，但它能运行矩阵乘法和windows vista，在底部你可以想象出最漂亮的英特尔新内核。
我在多个核心中找到了七个，三级缓存，所有这些强大的东西，所以你想象你有硬件，不是串行硬件，旧学校还是新学校，其中有多个核心，多线程，下节课我们将讨论线程，所以这节课的关键部分是这四个都是可能的。
这四种组合都是可能的。
以及硬件中并行性的选择，顺便说一下，在这门课程中，我们教授，我们教如何构建并行硬件，我们教你如何编写并行软件，所以你把两块都拿出来是很酷的，因为我们看到整根手指都垂下来了。
我们讨论的是并发软件的两个级别上的并行性，就像vista可以在串行硬件上运行，正如我提到的，给大家一点时间，矩阵乘法可以在并发硬件上运行，这只是意味着你只能抓住其中的一种资源，和工作的时间。
所以这是一张很好的照片，向你展示这些是独立的选项，你应该可以在今天的软件上运行旧的学校硬件，理论上只要给一点时间，以及串行软件，只是一个并行硬件盒上的小矩阵多程序，其中它都将借用一个核心和一个线程。
做你的小矩阵乘法，并对此感到非常高兴，好啦，所以两个独立的东西，并发硬件和串行或并行软件，弗林分类法是一种说法，如果我有并行硬件，这种平行的思维方式是什么，是指令并行吗，在这种情况下。
多个指令可以同时发生，喔你是说，我可以同时做广告和装货。
是啊，是啊。
所以我可以只做一个广告吗，我不做两个指令，只做一个广告是一回事，我的手术广告是什么。
但我同时加了四样东西，或者同时做八件事，好啦，林恩的分类法是关于我是在瘫痪指令吗，这里有不同的东西，同时有帽子、帽子和担子，还是我在一个指令上瘫痪了我正在做的事情，所以我们今天就来谈谈。
最重要的是那梯子，它是关于今天关于许多事情的一个指令。
在下节课中，我们将讨论线程级并行性，在那里我有多个不同的事情同时发生。
多重指令，好啦，照片是这样的，以下是你到目前为止所看到的，真的很好笑，生活就是这样，我想看看，如果你在生活中注意到这一点，我在这里的时间足够长，我意识到，记住，我们以为我们开始讨论直接地图缓存。
然后我们说不，它们是完全关联的缓存，然后我们意识到实际上我们已经硬编码了一个变量，就像集合的联想，我说我在教你n等于一组联想，直接地图，所以我锁定了，但事实证明n实际上只是一个，那里有个旋钮。
但我们只是为其中一个例子硬编码，所以我们了解到的是，到目前为止，有一个旋钮，我的指令是多么平行，我有多平行，这就是房间这边的指示，我听说我的数据可以，我们还没有真正谈过那件事，我们只是在用简单的方法。
一条指令在一条数据上，好啦，这就是我们目前所做的，很简单，我的指令池是一次一个指令，好啦，醒一醒，是广告，好啦，你在加什么，或者你可能会添加什么，需要两个数字，但是你知道，关键是。
你知道你在做一个简单的指令，也可能最多两件事，永远，就是这个想法，我有一个处理单元，顺便说一句，这叫做单指令，生活中每一天的单一数据，PC加四，你在干什么？我是一个单一的指令。
那一天你在单条数据上做什么，可能是两个数据，你知道的，是啊，是啊，是啊，是啊，一个广告需要两条数据，好啦，就是这个意思，所以所有这些都意味着，使用老派软件的老派处理器，我们只考虑并行性，否。
平行性一次一个，做点什么没什么难的，这个叫sii。
这就是这个讲座的内容，我已经说了三四次了，我再说一遍，一个广告同时做四件事，所以我们真的是八个人，因为我把这4加上这4一共是8个，所以应用单一指令流标准的计算机，你以前所做的一切，PC加四或PC加四。
一个指导小组一次做四件事，那真的很酷，快了四倍，我们喜欢这样，想象一个图形处理单元，想象一下你的GPU在做什么，现在，有一个GPU驱动监视器，很清楚为什么我有高清晰度，十九二十乘十。
八十乘十九二十乘十八十，谢谢二千二百万，两百万对，两千乘一千，大致，它大约有两百万像素，每一个也许三十分之一，六十分之一秒，我是说那应该有多亮，我不知道得有人计算，所以这是疯狂的平行，就是说，更新自己。
二百万件事情的六十分之一秒，你有多聪明，你可以想象一个GPU真的被推到了极限，与一些三维模型，你知道在驾驶模拟器上，我得弄清楚，那个像素的亮度是多少，这是两百万个独立的计算，每秒发生60次。
也许是高端GPU的二十个，所以想象一下，那就是操作是，你有多聪明，就这些现在是0到2 5穿过三条红色通道，绿色和蓝色，它经常平行地做这件事，所以你已经知道这是你以前见过的东西，每次你看你的屏幕。
你的终端，你的手机在做这个，它在说你有多聪明，仅此而已，我在问你，你有多聪明，每一个，你知道1601到1220到秒，所以并行数据，一条指令就在这里，你有多聪明，还是让我们做这四个的广告，再加上这四个嘣。
把它们砸在一起，那是它的演讲，这就是所谓的SIMD单指令，多个数据现在你可以想象我要去哪里，所有可能的指令组合都是单数或多数，数据是单倍的，星期一我已经给你们看完了。
我们要介绍这个东西，就是这里了，这就像整个右下角，图的右上角，如果左边的图是单的，右边有多个指示，单在底部在顶部用于数据，就像图的右上角，右上角总是您想在任何图形中访问的位置，让我们看看图表的右上方。
这是带有多个数据的多个指令，所以我不仅可以，我把四个数字加到另外四个数字上，但我有多个指令同时发生，所以这个指令说在这四个上面加四个作为广告。
说明书上说，拿这四加四，做一个XOR或其他什么，所以这真的很酷，您可以想象您的代码有多快，有多精彩，如果这两件事我都做了，所以我是钥匙，我是钥匙，我们以后再谈这个，我们不会那样做的。
这堂课我们只是在做Simi，但我们要去伊米伊米是终极的，我们想做一般的明迪，顺便说一句，每个多核，每台仓库规模的计算机，可能你所有的手机都在做imi，我告诉你的这些都是你口袋里的东西。
我五年前就会这么说了，五年前你连电话都没有，但我们今天肯定有。
明迪，你的表可能快走了，很神奇的东西，这里的东西，我们可能在这里喜欢，图表中没有太多意义的部分。
如果你有能力把四个数字加到另外四个数字上。
在一个时钟周期内发生加法，为什么不使用多个核心来做到这一点，所以这是单指令，我说多重指令和多重指令，但是单一的数据，我不能用四个广告了，即使我能做到，有电脑是没有意义的，在那里你可以有多个指令。
但实际上只在一个人身上做，你知道的，一次两个数字，那太傻了，如果我们有这种能力，所以这个叫MII，我们不这样做，真的不是没有人为它制造硬件，如果你要这么做，你写MD硬件，具有多个数据的多个指令。
所以D女士并没有真正被使用。
好啦，谁想出了这个叫做分类法，你以为，想象一下，达尔文，你怎么决定，你知道什么是，哎呦，是一匹马不，是驴，是骡子，这是一个分类法，当你看着这个世界，把它分成几部分，我是弗林教授，谁谈到数据流。
这是我的回忆，呃，这是指令流，MIMD SIMD单指令，单指令，多重数据，所以我们将属于这一类，这个盒子，西姆德，这是，我要告诉你，我们想在右上角，我们应该把这个翻过来在底部有一个，这是明迪。
我们下次会讲到，目前的新三叶草镇或更新英特尔硬件，确实有D女士和Sid是老派奔腾的例子，四台机器，所以这是一种标准，他就是弗林教授，我们称之为弗林分类学讲座，我们在那里解释这个。
我们今天谈论的是SIMD，然后又是MIMI，但现在你知道他们是什么了，但如果我在你走之前告诉你，西姆德，这就像要做一个新的希腊语单词。
现在最常用的，Simd和Imi在那里谈论，那是最受欢迎的单曲节目，多数据是最常见的并行处理编程风格，我们以后再谈，SIMD正在使用专门的硬件，今天都是关于专用硬件的，你是怎么做到的。
你怎么能一次做四个广告，那不是我们建造的，我们在管道中建立了一个数据路径，使用数据路径和控制来运行我们的CPU，我们没有能力做到这一点。
那么您将如何修改您的系统来处理这些问题呢？OK当然适用于数组。
对呀，如果我只想把一个数组添加到另一个数组中，那么让我们来谈谈七十个建筑，数据级并行，一次手术，多个数据流，这是它在当前软件中的样子的图片，我们在加州大学伯克利分校教非专业学生。
这是一种叫做Snap的编程语言，基于许多编程语言，支持这种范式，蟒蛇也是，也是如此，很多熊猫，很多，情况想想这里的一个数组是数组，把它们加在一起，能够将两个数组添加在一起是有意义的，下面是数字。
一到四是数组，我再乘以一个月，我在一次手术中得到了1-4-9-16，我甚至不认为我没有三思而后行，我们在教本科生时谈论的领域，我们说乘法的定义域是什么，思考数学，什么能成倍增长，作为输入，他们都说数字。
他们都很自信，人数，我说如果我把它扩展为列表或数组呢，你能不能，把乘法取数组有意义吗，他们都说不，太疯狂了，这没有任何意义，然后给他们看，他们就像等着，其实有点道理，有一个数字列表。
让这些数字我可以把它们加在一起吗，我可以把它们相乘吗，是啊，是啊，为什么不考虑一下呢，这真的让他们了解了你可以在软件中考虑什么，我说的是，如何构建一个硬件来在一个时钟周期内实现这一点，这就是有趣的部分。
这就是我们正在谈论的，但在软件层面，有高中生，中学现在使用这些技术，所以这真的很酷，你可以用一种简单的方式思考，他们不是在写多核心的东西，但他们在中学可以用简单的方式思考，就是那个操作，它不整洁。
所以我只想确保我添加了幻灯片，以确保这个想法，不是吗，它不会火箭科学，孩子们可能会普遍地思考这个问题。
这是我的系数数组c，我得到了一个向量x，它们的长度都一样，我基本上是说，我应该得到i的c乘以i的x，这就是你在快照代码中看到的，对于大于或等于零且小于n的i，好啦，所以我在一个数组中有n个元素。
我应该能在一行一行里说出来，它只是碰巧起作用了，真的很棒，如果成功了，我希望这将在一个指令中工作，因为n是大的，所以就像我们在研究它的进化一样，他们首先从四件事开始，然后他做了八件事。
所以现在你看到了能力，他们增加了制造和更大的能力，今天每一代的硬件，这真的很酷，那就更快了，硬件，你可以看到，所以一个指令被提取解码为整个操作，乘法都是独立的，这是关键，不会打架的，不是很好。
这是一个邻居的函数，有点不同，我们说的是所有的乘法都是独立的，我们经常称之为尴尬的平行，因为如果你考虑数组，意思是它是如此平行，很尴尬，根本没有人是邻居，如果我有一个小机器。
你知道一只轮子上的小仓鼠就能做到，每个人都可以独立地做这件事，对于每个数组元素，他们需要了解他们的邻居，这是令人尴尬的平行想法，就是我们在这里讨论的，顺便说一句，我们还有做流水线的机器。
所以我们还在做其他事情，但我们只是在谈论一个发生得很好的手术。
那这一定是最近的事，对呀，因为多核是最近才出现的，这一定是最近的想法，否，1957年在麻省理工学院我的母校，我们正在造一台叫TX2的机器，这是TX二号的照片，这是他们手册上的一张图片，德克萨斯二号。
如果你放大，我来告诉你这是什么样子，多酷啊，这是1957年，比以前多了十年，我出生在，好啦，开始了，所以应该强调，AE代表算术元素，程序员可以同时实现几个算术元素。
你可以在一个3个6位宽的数字上工作也可以在两个18位宽的数字上工作，给出两个完全独立的18位算术元件，它们分别是，但同时由正在执行的指令控制，你也可以做四个九，这是在他们得到应该是81632的想法之前。
他们只是随机的，九岁，十八岁，三十岁，他们真的不在乎他们的部分有多宽，这些话是如此的看看这个，这是一个非常大的想法，三十，六位宽数，这里有作业，或者两个18位宽的数字，每十七位的星等和一个符号。
或者看看这个，一个8和一个20，这是九块二十块，七四个九，那不是很酷吗，你看这一九一九二，七位数字和一个九位数字，你为什么要再做一个二七和九，我们回头看这个，我们学到了一些东西，但他们这样做了。
他们有你想要的任何东西，我们能应付，我们要制造硬件来处理三个六个或两个，十八二十七加一个九，这几乎就像做出改变一样，就像做出改变一样，给我25美分，我有多少钱一个旧的周六现场小品，你应该看看这个。
我们做出改变，这就像一些银行，我们做出改变，你给我们25美分，我们可以在五分钱内给你两次，我们可以给你五个五分钱，我们可以和你一起工作，这就是笑话，他们能做到的，你给我三块六。
我可以做一个三六个位的数字，我听到两个7比9，我们可以和你一起工作，一九五七年六十年前，所以在个人电脑的早期。
他们为这种新酷的东西做广告。
这个想法变得流行，我我说我在这里看起来像奔腾，奔腾一号，奔腾2英特尔在他们的硬件上引入了这些扩展来做到这一点，他们知道你知道我们在做什么，人们不能同时播放MP三流流，因为他们在做别的事情。
就像我们会跳过，你回到过去，你可以播放它，它会跳过，你在放音乐，它受不了，显然更快的机器会有所帮助，但他们意识到如果我们能，他们只是三队的常规操作，你在为整个溪流做什么，为什么我们不能一次做四个呢？
所以英特尔添加了这些SIMD指令，找一条指令，做多个指令的工作，你可以同时做四件事，如果你有四件事要做，一次做四件，他们称它们为早期的多媒体指令MX，他们真的是在播放MP3文件，也不是真正的电影。
但几乎是关于媒体，因为媒体是电影的一大长条，很多帧，他们都是一样的东西，你只是在做同样的事情，对于每个像素，对于每一组像素，你在做同样的事，所以多媒体是一个非常容易使用的案例。
为什么他们要使用SIMD指令。
后来他们有了一种叫做SSC流式SIMD扩展的东西，但无论你说什么，西迪这个词，你知道我们在做什么，这就是源头上方的照片，一个有四个X的来源，两个有四个y，我做了个手术，x一个行动x x x行动y。
对于所有的四个元素，就这些，如果你走开，学会一件事，只是那张照片，这就是我们要做的，这就是我们的目标，所以再一次，这是一个柔软的开口。
不太复杂，那么它的演变是什么呢，当我们作为英特尔的发展，也许你从屏幕的后端看不到这个，把灯关掉，他们告诉我们可以关灯，很难看到这一点，放映机不够亮，给大家看一下，他们开始了MMX，所以我们在这里。
我们从MMX奔腾2开始，有多宽六十四位，哦六十四位，我一次可以做两个三个两个两个花车，那很酷，所以我可以做漂浮，哇二哦大不了二，然后他们搬家了，就像你想象的那样，一百二十八，我一次可以做四个花车。
顺便说一句，这些是x86上面的扩展，X6还在工作，但如果你有，如果您使用分机，你有硬件来支持它，突然间你得到了很大的性能提升，一百二十八，看看这个，现在我们在核心沙桥，现在我们有256个，哇五十二。
看看这个，太神奇了，所以他们真的扩大了Sithessimi寄存器的宽度，我们增加了新的寄存器，这些是他们所说的，现在他们叫他们斧头，一个X是五十二，所有这些花哨的名字。
从本质上讲。
你有什么想法，嗯，你有这些非常非常宽的寄存器。
真正宽的寄存器，您将它们作为这些SIMD寄存器呈现给用户，所以为了让它起作用，你拿着你的数据，你把它复制到SIMD寄存器，你在SIMD寄存器上做一个广告，你可以把它复制回来，就是这个意思。
所以这是一个特别的地方，这些XMMS是，顺便说一句，你必须告诉他们他们是什么，你必须，你得声明它们是什么，是一个很大的数字吗，是一百二十八位的数字吗，还是两百六十四，还是三四三二，你得告诉她是什么。
所以一二八协议，单精度浮点数据类型表示单精度意味着浮点，浮子，单精度意味着浮动，双精度双精度，这只是意味着浮动，同时进行的方式，你所研究的不是整数数据，几乎所有人都在谈论浮点数据。
只是想让你们都知道多媒体就是声音，是关于浮点数据的，不是关于整数数据，所以让我们确保我们在这一点上意见一致。
这是英特尔架构的图片。
顺便说一句，这里有一件疯狂的事情，英特尔调用一个词。
十六位，我们的话是三个二位。
当你在屏幕上看到一个词，那是我们想象的一半大，作为一个词，他们叫三十二个比特。
双字，所以一个正常的浮动，浮子，单精度浮子。
他们称之为双字，我们会把这个词叫做，只是确保你完成了他们的双精度浮动。
他们称一个四字，那么什么是双序呢，所以如果我有一百二十八位。
如我所说是一百二十八位，你可以像在麻省理工学院一样对待它。
两天，你可以把它当作一大堆16个宽数字。
有点像半浮。
或者实际上，这都是字节，这些都是字节，打包字节，或包装的文字。
是半个字，这些是我们的花车或双人花车的包装花车。
你看他们的名字是不同的，因为他们确实有，所以你可以做，你可以一次做四个花车的想法。
就像我展示的照片一样，四个Y，我可以做手术。
所有这些都和我在屏幕上给你看的一样，也没什么特别的，但你能再做一次真的很酷。
这是，啊，现在你可以去5点12分，这是他们秘密的东西中的一张照片，当你移动到斧头时，你现在斧头五五十二斧头是二五六，SSC是一二八，AX512是512位宽，您可以再次进行这些操作，你想怎么分就怎么分。
这是一个内部，如果你读到底线，它说不是为了不是为了你的眼睛，只是这是一个内部的东西，在某个时候被释放了。
欢迎当然，这是你可以输入并进入你生活的东西，他有一台笔记本电脑，转到提示符并键入，转到终端提示符并键入ls cpu，那是常见的手术，它并不是在所有系统中都有效，如果你看到，如果成功的话，你会看到很多。
只是硬件是这样的，可以从软件中查询，我在强调，你看不到的，也许你能看到，听到FPU，SSC，SSC，两个AV x五个十二CD，这些都是代码说，我是硬件，支持这些SIMD操作。
因为我已经为他们准备好了登记簿，有点整洁，所以输入lcpu，想要什么，看看你是否在寻找叫做sse或v x的东西，如果是基于英特尔，如果是M，它可能非常不同，一个有一个，当然是一种不同的做事方式。
你还有一台英特尔硬件笔记本电脑，去看看，查看lcpu的功能并查找短语，VX SSSE，我以前说过的所有事情，有点酷，这是硬件申报的一种方式，这是我要给你的东西来支持你的软件。
那么你是如何处理的呢，我们现在怎么想这个。
让我们真正地下来，在我的演讲中完美的时机，到目前为止，你实际上是如何做到这一点的，假设我有一个巨大的数字数组，一百万个数字，大数数组，我想平方根，每个人都想自己取每个值和平方根，把它放回原位。
这就是我想做的事实，我想这么做，f等于f的平方根，F是一个大数组，我想平方根，数组，平方根取了一个列表，十天后记住平方根，只接受数字，现在它需要一个列表，我想重置F，将f重新绑定到f的平方根的结果。
所以这个数组中的每个数字都有平方根，把它放回原位，这在SIMI中是如何工作的，就像我说的，你得把它复制到，在那里做，然后带回来，那么让我们来谈谈我们如何做到这一点，那么家庭作业是如何坚持的呢？
在今天之前，坚持意味着老派的方式，对于数组中的每个f，我得把f加载到浮点寄存器，实际上有浮点寄存器，你可以在风险5中查一下，它们是浮动寄存器，计算平方根并写回，将值从浮点寄存器写回内存。
因为很明显这是从内存中加载的，在我的浮点寄存器中执行该操作，不是正常寄存器，浮点寄存器，然后把结果写回来，好啦，就是这样，那么SIMD是什么，做什么，如果我有一台机器，必须立即做。
所以我基本上把我的数组分成四个块，我说让我装四个元素，不是一个四个元素同时进入我的，如果我可以，这是一条路，就像你要去萨克拉门托，去萨克拉门托帮我抓四个元素，把他的东西带回来在我的宽SIMD寄存器里。
在一次操作中资本的平方根，然后把这四件事的结果写在一条指令中。
如果你能回到记忆中，就是这样，所以还是要做三次手术，但我的效率是你的四倍，我比你快四倍，处理那个数组，那不是很酷吗，亚当，SIMD寄存器显示路径，是呀，是呀，这是正确的，数据路径是我们所知道的一切。
都是电线的问题，我们知道，要让它工作和控制，只需告诉你将数据推送到哪里，那里有些井，你可以画一条模糊的线，说这是我所有的登记簿，或者你可以说好，这是整数寄存器文件，有浮板登记文件。
这是那里的SIMD空间，就画一条模糊的线，它是如何在您的系统中构建的，你不用担心这个，只是个特殊的接线员，你只需要知道，特别行动，做正确的事，如果他们是分开的，他们可能会分开。
因为你记得有一个标准的注册文件，那是三、二比特宽，风险五，我要给你看一片，风险五是考虑增加70件事，所以会有一个不，第三个两个宽的，但是一个单独的寄存器，会有一个特定的命令，上面写着去记忆。
把它放在更广泛的寄存器里，悉尼登记处，而不是32位宽的寄存器，所以它们不在标准的第三宽寄存器中，另外还有一件事，现在您是否将其视为全局寄存器文件的一部分，或者在这里，在这里，这取决于你想怎么想。
你有什么问题吗，哦耶，好啦，是啊，是啊，所以你继续，是呀，哦我的天啊，好问题，心肺复苏术有特别的指示吗，那是特别指示，那是一个神奇的指令，带着四样东西去萨克拉门托，我们说的不是现金。
我们说的是去萨克拉门托，别管现金了，这是在没有现金的情况下存在的，顺便说一句，我们不是在说现金，在这里，像以前一样去缓存里抓，你抓住一个街区，你试着让它尽可能高效，现在我说的是去拿四样东西。
最好是相邻的，我不是这里的人，一个不不不四个连续的东西把它们放在我的SIMI寄存器里，这就是我们正在谈论的，我得做一个特殊的手术，这三个都是特别指示，加载是一个特殊的指令，做它是SIMD指令。
然后复制回来是一个特殊的指令，储存回来，所以这三个都是特殊的指示。
使我的系统现在快了四倍，我想我回答了你的问题太棒了，所以这是一个例子，我们实际上深入了一点，显示更接近代码，顺便说一句，我要和你们分享幻灯片的结尾，我希望他们印出来了，有一个很好的例子，这叫做矩阵乘法。
我们没有时间的例子，那是，但是所有关于如何做到这一点的细节，所以在这里我要给你一个大局，但请随意通过矩阵乘法，上午，我要向你们展示一下发生了什么，假设我有两个向量，V一，这就是我想要的，我想要的。
我想到这个，顺便说一句，这是一个，这就像直接从图形中出来的，如果你选修另一门课，叫做，我在这里当研究生时教的，我想是八到十次，我喜欢这门课，你经常有一个点有一个X，Y z和一个W，w可以给你透视投影。
所以你必须有第四个坐标，当你在空间中有这些点，我们除以w，你就得到了这个美丽的透视投影，所以你必须继续第四维度，这是伟大的，如果你有什么，你可以同时做四件事，所以这两个向量x y z和w。
v1和v2想把它们相加，然后把结果填充到向量结果中，就像我之前说的，但现在我们讨论的是一个数组，我们说的是两种不同的四英寸宽的，四位非四维宽数，好啦，所以记得我说过你必须有三个指示，把它移过去。
做完再放回去，下面是三个说明，第一个叫做移动APS，V一的地址，无论你住在哪里，希望x、y、z和w在内存中不是连续的，从内存移动到XMM，我给你看了XMM是收银机的名字，xmm寄存器。
一条线就是边界上的一条线，包装意味着没有空隙，单精度意味着它是漂浮的，好啦，四个花车，意思是拿出4个彩车装到一起，嘣嘣嘣嘣，把它们像床块一样敲碎在一起，从内存添加到XMM寄存器，所以在这里。
这个看这个是做什么的，这在一个指令中很迷人，这是关于这不是，这不是简化指令集代码，其中有加载指令或操作指令，或者商店，这就是我们在过去的日子，他们现在做什么，看他们在做什么，我们没有这一切都在风险五。
这就是为什么x86要复杂得多，上面写着凭记忆复制，这是我的记忆错误，从内存复制到我的X和M寄存器，下一个说在一个障碍中快乐，为V二的另一部分记忆感到高兴，并添加到这个登记册上，那不是我们曾经拥有的。
我们已经把它带进来了，寄存器路径中的操作员寄存器寄存器寄存器，然后把它放回记忆中，我们只有这些，我们有很多货，不是这样的，这是加载第二行，这个广告PS说加载广告，同时，我们从没谈过这个。
就好像我们都在这个世界里，那是中投公司级别的指令，非常复杂的指令，同时加载和添加，我把它塞进XMM零相同的地方，最后我需要拿XMM零，它现在包含和并将其放回向量结果中，就是取x，mm，0。
然后把它放回矢量结果中，这和从xmm回到内存是一样的，所以第二个很奇怪，他们应该带我们四个，就像四个手术，加载一加载x，我们叫它什么，负载v1负载v2，做广告放回去，这是蒂多在三，因为有复杂的指令。
因为第二个是同时装出来的。
很奇怪，我们以前没做过，我现在如何用代码做到这一点，让我们再低一点，我快要让你看演示了，示例，矩阵相乘，我们有一个叫做本质的东西，我们谈过他是什么，内在是C中的方式，你指定我几乎就像指令一样。
您指定一些映射到相应指令的一对一行，所以你在写C代码，但看起来您实际上是在用C代码编写汇编程序，左边以此类推，我有下划线的数据类型，一种特殊的类型，M128D上面写着我有一个128bit宽的。
那里的向量，装载和储存只是我们说过的移动。
记住mov a d加pd乘pd。
这些是一些加载和存储以及一些算术操作符。
当你写的时候，变成实际的x86，这做了四个位宽。
把四个位移宽，推四字节加法做一些特殊的事。
所以你只能用c写，如果您有运行在英特尔硬件上的代码，那是x86兼容的，因为我们在谈论，只是x86世界的一部分，不是风险五，x86。
所以回到风险五，现在你说的是x86。
你为什么说回城，六班都是风险五好，因为我想让你知道，遗产现在，我们又回到了风险五，他们正在考虑把它们添加到草案中，是…的提案草案，我们怎么做，我们注意到，但很明显它已经存在很久了。
但是第一个版本没有任何SIMD操作，我们必须这么做。
我们必须是真实的，我们要有真正的表演，你得做一些模拟的事情，你为什么要把它做好，那都是草稿的一部分。
所以拿什么指令，做多个指令的工作，表示向量指令的运算符。
向量寄存器的前缀V，所以他们会有广告，把它塞进目的地，所以这就是我们在系统结束时如何做到这一点，假设他们是5比12，不妨尽最大努力，x8，6，5，12现在的号码是多少？让我们从那个开始。
然后五十二条河流轰隆作响，那很酷，不错嘛。
对呀，如果我做了矩阵乘法编码和C与AVX指令扩展，比天真61快多少，没有AVX的蟒蛇，你能跑多快，只要给我一种感觉，一次一样，同样的速度，该死的来吧，同样的算法要快十倍。
快一百倍，千千万万。
什么能给我一个粗略的感觉，这是信封的背面，C和VX在一起快多少。
只是天真的蟒蛇，小为循环，只有这么好，非常漂亮，温柔的循环，你看看你，看看你有趣，你给我手指什么的，我们到这里来，我们走好的，你做得很好，其实看看这个，哎呦，一百，十万一千人并驾齐驱，看赛马是一种乐趣。
看着你一千个。
答案是9961000获胜。
为什么这是你得到十亿个千兆浮点运算的图表，千兆亿，记住百万千兆亿，我说千兆，是十亿，如果我说gibi，那不一样，我刚刚做了这么多，用于简单矩阵的Python失败，乘法矩阵乘法是一个n次方运算。
如果想想Mulus的繁殖，所有的元素都是这一行和这一列，对于n的平方，所以每一个n平方的人都有n个东西，只是想想，还记得考虑什么矩阵相乘吗，它看起来像一个n立方体操作，那是相当昂贵的手术。
所以它不是很强大，看看这个失败的极客，顺便问一下，我们得到了什么，一台英特尔机器的理论极限是25千兆浮点运算，所以我只是从Python到C语言二百四十次，这就是为什么我们教你快240倍。
如果你只是从那里到那里，顺便说一句，你觉得怎么样，去找斧头的速度有多快，我做四到一次四，所以速度快了四倍，那是九百六十，它大约快一千倍，所以在浮点算子上关心速度的人，我不是在说浮点运算上的整数，是呀。
用Python编写算法很好，但是孩子，如果你想在真实的东西上运行这个，你要做一个模拟器，星期一给你9点60分，我说的是做咪咪，现在呢，我有多个核心，所有做这件事的人，所以你会得到很大的推动。
当你说到德拉尼亚有一个问题，我喜欢，否，它是，这看起来就像你在问的问题，它们是什么？它们是图书馆吗？他们是图书馆，它是汇编代码，有组装说明，移动API，x86的汇编级指令，从字面上看。
这就是它的工作原理，在线下，它实际上是在向向量移动，把那个空间做得很好，所以你在C中，我如何确保有那把特殊的斧头，这些就是本质，你把内部函数放在c中，它会确保这成为字面上的线条，去做正确的事。
那很难调试，你得想办法解决，因为如果你不打包，如果你不在，如果不是四年数组的倍数呢，你要做一些奇怪的事情，所有这些对于能够调试都很重要，你得先让你的代码工作起来，在你开始研究你的一个基本问题之前。
想想唐纳德·独木舟，亚当喜欢编译，它是编译器的工作，但你是C程序员，编译器接受这一行并直接将其映射到移动AP，但你必须补充说，如果你不这样做，如果你不做，你会是，你可以写，你可以写C代码。
这只是一个传统的n立方体的东西，它不会使用BX指令，即矢量静止不动，因为你必须把线放进去才能明确地移动，所以你必须考虑，您的数组是什么样子的，如何四个一个地移动，如果不是4的倍数呢？所有你要处理的事情。
获取代码，它没有优化，我喜欢你的想法，为什么不能有一个更聪明的编译器，我的意思是，为什么你不能有一个更聪明的编译器，你知道我看到你在做，你知道它几乎就像一个小剪贴板家伙，剪裁，你知道。
我看到你在做这种大的扫描和阵列，你不想在这里使用AX扩展吗，可能是未来的编译器，无编译器，我知道会自动做到这一点，未来的编译器可以自动做到这一点，太美妙了，或者你可以看看更高级的语言。
为你做的只是建造正确的东西，就像你可以生活在Python这样的语言中，可以用AX6编译成C，也许你知道你可以考虑从编程语言系统中构建不同的东西。
总之我们今天有点早，首先我想确保每个人都知道这是一个非常详细的例子，我只有三分钟的时间，这是一个60英尺的滑梯，我就像我不能做60张幻灯片，所以我把它全部推到例子中，你可以看看你自己。
这就是实际做矩阵的细节，再乘以这些斧头交换，他们不是风险五，所以你必须学习x86，一点点，这有点烦人，好啦，我们看到了他们中的四个，我们看到希德，到今天为止的一切都很简单，星期一有雾。
没人记得有一个情报，AVX L和SIMD指令因位宽不同而不同，随着这些指令的演变，他们从六十四开始到一二十八现在是件大事，四个花车是二十八，然后二六，那是八个花车，现在呢，他们大约5岁12岁。
也就是十六个花车，在某个时候，太棒了，它大约是多媒体的16倍，论多媒体数据，太棒了，总的来说，你怎么做，你在本质中看到，总的来说，咒语还为时过早，优化是编程万恶之源，非常感谢，每个周末，伙计们。
我们星期一见，当我们了解到吴敏迪，好东西。
P38：Lecture 29： Parallelism I： Thread-leve Parallelism - 这样好__ - BV1s7421T7XR
其他发生的一切，你的周末过得怎么样秋天到了，当然可以是的，暴风雨要来了，所以明天会下雨，注意那个，明天下午带把伞，我想他们说星期二会下雨，也许周末晚些时候会有一些，但希望我们肯定需要它，我们当然需要雨。
很高兴见到你很高兴见到你，季节实际上在改变，我将在新闻部分向你展示这个非常有趣的计算，就在这里，如果我点击这个启动它，这是谁记得嗯，这是一个大英雄六，大英雄六，你知道的，还有这些小机器人。
他做了一个机器人，一小块机器人可以像那样重新连接和自我配置，那是不可能的，记住大英雄六，当你看这个的时候，迷人的，引人入胜的工作，准备出发，我我想我不应该。
我做的。
就像一张脸知道这一点。
但事实证明，你可以有一种天性，并在上面签名，然后它们只与一个特定的签名对齐，所以你可以说，让我们用上面的签名来建造一个魔方，两个七个子立方体对每个必须连接的脸都有签名，如果两张脸不匹配，它们就会爆炸。
我们只是互相反弹，但当他们碰巧撒谎时，他们会一起去拍照，就像两块磁铁，所以不仅仅是你，你知道的，你被吸引了吗，你被排斥了吗，这是磁场的特征，只有当你以正确的方式对齐时，那不是很迷人吗？我觉得很有趣。
好啦，挺有意思的，所以让我去下一个，但是。
好啦，所以让我们开始吧，女士们先生们，万圣节快乐，每个人，很高兴有盛装打扮的人，谢谢你穿着戏服来，我也爱我自己，很好玩，谢谢你庆祝这一天，稍微改变一下总是很有趣的，我有个笑话给你，这就是问题。
为什么61不能，C学生说出万圣节和圣诞节的区别，这是经典的，你得知道这个笑话，你得知道这个笑话，我一直在等待，我等了一整年，我喜欢在秋天教书，因为这与它无关，因为10月31号或者10月3号，三一八等。
十二月二五，十进制基数二五，非常感谢，非常感谢，这不是我的玩笑，它不是，这是个众所周知的笑话，当然不是我的，我没有，如果我，如果我是，我会更高兴，但这只是个玩笑，我听说我想和你分享。
我们周五有一个关于平行的软性开场，我们看到西米在思考这个文化，现在我们要谈谈线程，一个大的新话题，这是正式的开始，一个名为线程级并行的新主题的正式开始。
但是让我们回到过去，看看并行计算机体系结构。
你打算如何并行地建造东西，为什么我们要平行地做事情，这门课提高性能的目的是什么，我们当然知道我们可以建造一台机器来处理我们的程序，那没什么意思，我们在连接硬件或软件之前就已经这样做了，已经完成的部分。
但现在我们已经建好了，你会怎么做才能让它变得更好，你会有更高的表现，你能做什么，什么是，你有几个旋钮，当然，最简单的旋钮是时钟速率，把时钟频率调高，把时钟调高温度有什么缺点，真的很难对付。
而且对环境也不好，你那样做效率不高，所以这是个问题，所以我们基本上是5千兆赫，你不会真的看到，我是说，你看到了伟大的，你知道的，世界纪录是8个，所以我们大约有5千兆赫。
在那个空间里低于2-3-4-5的东西，那是固定的，不能转那个，它已经很多年不能转动旋钮了，当丽莎和我长大的时候，当你们还是孩子的时候每年，哦，我有250兆赫，五百兆赫，1千兆赫，那是我们做的一件大事。
我们在转动旋钮，弗吉尼亚州，这是工作，它正在工作，丹纳德缩放仍在进行中，不能再做了，我们大约不到5千兆赫，几乎普遍，这就是我们接下来要研究的，我们谈到了较低的CPI，每条指令的时钟周期，太好了，辛迪。
一个崩溃周期，四个广告，那太棒了，这么宽，我们说的是更广泛的寄存器，咀嚼咀嚼XOR在四个不同的三个两比特量，我们喜欢这样，通常大部分是关于浮点的，所以通常是两个花车上的广告，四个浮点数，或者八个浮点数。
或16个低点数字，我们还谈到了降低CPI，当我们有管道，记住我们同时做多件事，所以CPI是这两个因素中的一个，更大的是什么，如果您可以同时执行多个任务，所以你可以有多个CPU，各自并行，喜欢这个。
任务可以是相关的，也可以是不相关的，我们一会儿再谈这个，如此相关，每个CPU执行，你知道矩阵的一部分，你在这里，我在下面这个矩阵里或者完全不相关，这对服务器来说很好，顺便说一下，考虑服务器对请求的响应。
每个请求都是完全不同的，你想要文件的这一部分，你想要网站的这一部分，你想把这个放在这里，服务器对此很好，因此，您可以将非常不相关的内容分发到hhttp请求中，超文本传输协议。
或者您可以在浏览器或电影中运行PowerPoint，你知道网络浏览器或类似的东西，或者你可以做所有的，我们将讨论做所有的，这基本上是你现在所有的电脑，全部做完，你把这三个都拿走，你得到了很好的性能提升。
还记得我们之前看到的一些并行是免费的吗，最低层硬件描述，那三个二比特，我得到了一个A，一个X和一个Y，我将以，那些都是免费的，他们只是碰巧用这种方式接线，我们不必在体系结构上做任何明确的事情。
我们当然建造了它，我们建立了数据路径，我们对此不做任何明确的事情，我们得到了免费的管道，我们当然有建筑师在工作中，建筑师和，你知道的，戴上我们建筑师的帽子，你得一起打造，但一旦建成。
你只是从软件的角度来使用它，所以那是免费的，精通软件，我们讨论了一点并行数据，SIMD不是免费的，您必须在C代码中显式地添加这些内部函数才能使其添加，你得把它复制到大宽矢量上。
你得加上矢量才能把它带回来，所以你是手工做的，我们将讨论并行线，这又是你明确地做的事情，这不是免费的，通常，所以我们得考虑一下，当然，您可以有一个未来的智能编译器，对你来说就是这样。
但现在我们必须自己明确地做到这一点，你要控制它，这是伟大的，我们处理这部分硬件，其中的一部分，我们的口头禅是什么，我们与平行性有什么关系，明确，我们的口头禅是什么，唐纳德·克努斯，我上次展示过这个。
我们的口头禅是什么，过早，是万恶之源，至少在编程语言中，所以你要确保你想让你的程序，当我们讨论显式并行性时，确保你让它工作，在决定添加线程之前，在你决定让它平行之前，那样的话。
只要确保这对每个人都是一致的。
好啦，体系结构，他们回来干什么，啊，我不知道什么会看这个，那可能是这是顺便说一句，伯克利的一些作品，他们在做什么来恢复平行度，也许在，80年代，我们要说左上角的图片，从80年代开始，你想有平行的。
如果你买了很多电脑，你把他们都放在演讲厅的每一个座位上，你在那里放一台电脑，每个人都在运行不同的程序，或者某个大项目的共享部分什么的，你怎样才能把它们很好地连接在一起。
这些计算机连接的唯一方式是通过以太网，所以以太网变成了，你知道的，我要用的词，就成了瓶颈，因为所有数据都要通过瓶颈，想想瓶子，你想把水从瓶子里倒出来，这里很宽，但是脖子真的很小。
所以瓶颈意味着一切都归结为一个点，所以以太网成了那里的瓶颈，让我看看，让我们大规模地这样做，我们去劳伦斯伯克利国家实验室工作吧，或者劳伦斯利弗莫尔实验室，我们正在进行大规模的气候模拟，你需要对每一个。
你可以想象我的工作有多酷，就像电脑一样，这块小广场上的工作碰巧在内华达州上空盘旋，我的工作是了解气候将如何变化，因为我在预测一些事情，所以我的工作，现在我邻居的电脑正在用邻居的电脑工作。
所以你想要有真正快速的互连，所以他们开始建造，这使得这些计算机之间的互连速度非常快，所以它并不遥远，就像嗯，我得通过电线把它转到这里，路由器通过以太网返回到这台计算机，让我们有那些互连，非常非常小。
非常快，非常紧，为此进行优化，因为有很多数据传输，还有那些大模型，我们也每个人都谈了这件事，每台计算机都建立在一个多核系统上，所以现在你有了跨计算机的并行性，以及一个CPU内的并行性，今天的课就是关于。
那些多核是什么，我们怎么给他们编程，我们今天要谈谈这个，他们是如何交流的，所以这叫做多核芯片，GPU当然有大量的并行性，多年来一直在做平行，如果你想知道每个像素应该有多亮，但是多核CPU。
我们上次讲了一点，作为一个数据路径，有一些共享的材料共享，L三，当然有一段记忆，我马上给你看那张照片，你的蜂巢机器用的是那些电脑，你自己的笔记本电脑有一台电脑，我的表，你的手表使用了这种多核架构的想法。
那么有两个核心意味着什么呢，我们只看了一张照片，一个核心，这是你第一次看到这张照片，它是这样工作的，有一个记忆，有一个很大的记忆系统，记忆可能很大，你知道在最新的Mac上，我想两年前你可以点两个。
一分是多少，5TB的内存什么的，一些疯狂的内存真的真的很大，就像哦，几场演出，是啊，是啊，你以为你得是个记忆很强的人，是啊，是啊，几兆字节的内存怎么样？所以内存又大又贵，你必须每个核心都有它们的副本。
因为它们当然很小，好像他是个，他是核心课程，就像一个，一个大硬币的模具，或者一个，你知道的，五十美分，那是一个核心的大小，所以我们说的是记忆，比那大得多，所以你有两个核心。
每个核心都有自己的控制和数据路径，现在你看到的每一个都将与记忆相互作用，所以现在在某种程度上，你在想这里的瓶颈是什么，记忆有一个，还有很多，所以当我们看这个的时候，好好想想吧，你知道的。
我的记忆保持不变，我们这里有两个核心，都能运行两个独立的程序，两个独立的，我们要在第二个线程中说。
一个节目的两个七部分，这就是这两个核心的想法，他们在干什么，它们各自执行自己的指令，单独资源，什么分开得好，数据路径，让我们回到这里，让我们看看什么，什么是分开的。
控制和数据路径，对呀，PC寄存器ALU都是分开的。
那太好了，那不是不，没有共享的东西的争论，那是我自己的小世界，我自己的小电脑，在某种程度上，每个核心在某种程度上都像老式的学校电脑，每一个都有最高的水平，在自己的核心上缓存第二级上的第一级。
你看到了一个共享的L三，所以在某个时候，他们开始分享，当然记忆是共享的，我们也谈过了，分享了什么，显然记忆，你说过第三级缓存，不是要求，所以我们把这个叫做，我有个新名字，确保我们明白这一点。
这就是所谓的多处理器微处理器，多处理器微处理器，也称为多核处理器，例如，一个四核CPU，我们谈到了同时执行四个不同的指令流。
那么什么是多核呢。
我给你看了这张照片，我相信我谈到了数据路径，然后呢，让我们都回忆一下，有一个故事，我喜欢这张照片，这是我很久以来见过的最好的视觉效果之一，让我们一起回忆我们一起讲的故事，我想我在这上面花了十分钟。
故事发生在2005年，如果我能让我的光标在2005年左右工作，来吧光标给我一些爱，不给我哦那里它，两千零五年，我们无法冷却，我们的CPU，我们试过液冷，我们试过油基冷却空气，风扇很久以前就坏了。
我们不能再给他们降温了，所以我们必须冷却我们的能量，我们不得不减少我们的力量，因为他们不能称之为，那么如何降低功率，把频率调平，而不是高歌猛进，一旦我们达到5千兆赫，四五个，当它变平时，我们就停了下来。
我们看到了没有并行标准的顺序性能应用程序，你正在学习的东西61 C写你的第一段C代码，所以没有相似之处，压平，表演正在变平，丹纳德缩放，你得到的地方，这种自由增长已经停止了，上面的曲线是什么。
顶部曲线的成员被称为，每个集成电路的晶体管数，摩尔定律，不是性能，但晶体管的数量仍在继续，那么你怎么处理那些晶体管你得到了更多，我可以装更多的晶体管，工程师们在世界的那个地区做得很出色。
建筑工程师的那一部分让曲柄继续运转，他们继续把更多的晶体管堆在我的，原来如此，但我的表现平平，因为我不能再加快速度了，所以看看我的小动画，准备好了，波普和哒哒哒，你增加核心的数量。
你用不同的方式使用它们，你把它们用在两个不同的核心上，一死，现在看看这个，现在你可以看到并行应用程序的性能继续，所以对数据的渴望并没有减弱，人们继续拥有越来越大的数据集，皮克斯想要越来越多的现实电影。
没有人能阻止对数据的渴望，所以你需要继续满足这种饥饿感，但你必须给它输入一个现在并行的程序，不是连环的，你以前可以免费做，你知道它叫激光，它害怕只是懒惰，懒惰的程序员模型很棒。
只需在第四个算法中写一个非常低效的结尾，只是风，计算机的电流越来越快，会确保你的表现很好，现在就有效，你必须对算法非常聪明，如何使用内存，当然使它平行，我在这里看到一个问题，告诉我你的名字。
你只有一个在那里一个，是呀，是呀，问题是当你有一个CPU，有一个alu吗，是呀，只有一个陆，你一无所有，不用担心，这就是你所拥有的，顺便说一句，他们在多辆车之前就有了危险建筑，但这些都是异国情调的。
你会在劳伦斯买到，伯克利国家实验室，在那里他们把它们和非常快的，你知道的，因特网连接，而不是把它们放在同一个模具上，是啊，是啊，接下来的问题，再喜欢一次，是啊，是啊，什么是，这就是重点。
那么越来越多的晶体管有什么用呢，如果你只有一口井，也许是一个大一点的一一二缓存，它们中的每一个都在这样做，所以你在扩展机器的某些部分，但你没有改变，事实上，你有一个ALU算术逻辑单元在做你的工作。
但你可以用另一种方式，所以这是一个很好的观点，但他们在想，过渡是什么？我们在某种程度上如何处理它们，对他有帮助，在那里再加一个，是呀，我是说，你还能用它们做什么，你可以做更多的异国情调。
更多我们现在还没有了解的异国情调的建筑，超级缩放器正在流水线是一件大事，你能让你的部分有多宽，但仍然很有创意，他们用这些晶体管，我们可以把它们放在那里，是呀，问题围棋，我们要担心的是，马修，马修。
未决问题，马修，我们要担心两个核心，同一地点的权利，女士们先生们，每当您有共享资源时，你得担心丽莎，我在抓遥控器，对两者都是，她现在有了我现在有了她有了，你们两个在抢一样的东西，您有一个共享资源。
你已经明白了，好啦，所以这是完全正确的，阿门，我们会更多地讨论这个问题，实际上可能是下节课。
但这当然是个问题，好啦，这里有一张照片，这是苹果公司的营销图片，谢谢你，苹果公司公开了这艘14并不是最新的最伟大的船，但他们至少应该强调一些他们想谈论的事情，这是他们在大营销活动中的照片。
这是你知道的那种事情，蒂姆·库克谈到，他会指出所有这些要点，但让我指出一些事情，与本课相关的，就像一个新的六核CPU，顺便说一句，那很酷，是他们的移动芯片，这就像一个移动设备，是我的iPhone。
是A系列芯片，不是一米一二，那是他们的台式机系列，这是一个手机芯片，我的电话，六核CPU，我们继续走，四核GPU，这是一件令人难以置信的作品，我是说你，你拿着一台超级计算机，你的电脑，如果你回到过去。
给那些在劳伦斯伯克利国家实验室，二十年前，你的手机会被吹走的，他们房间的电源在你的手机上，令人难以置信的是，在过去的二十年里，性能有了如此大的提高，比如说四核GPU，十六核神经引擎做人脸识别和照片更新。
或者他们在做什么，在人工智能方面他们的神经引擎，高级图像信号处理，难以置信的技术，人们在一起，这只是一个例子。
所有的公司都在一起，现在的芯片正在做他们正在做的不可思议的工作，和工程方面有所有这些核心，所以从2005年开始，这是很正常的事情，你以前找不到幻灯片，上面写着，哎呦，多核，那是件新鲜事，两千五就是全部。
这个时代的开始，所以马修说到共享记忆，每个核心都可以访问处理器中的整个内存，保持缓存一致性的特殊硬件，那是个问题，当然，我们将讨论下节课，优势很好，多么巨大的优势，如果两部分，两种不同的跑步方式。
我们要叫他们线程，但目前有两个不同的运行程序，我们会说现在都是，我们就是这么说的，共享同一程序，所以我想做乘法，您将此列添加，我会拿这个专栏好好补充一下，如果它是伟大的，如果您可以在同一个地方访问数据。
太多了，那样比没事容易多了，嗯，你抄到你那边，是啊，是啊，我抄到不不，事实上，这是你正在访问的一个地方，实际上使您更容易拥有同一程序的多个部分，访问我们喜欢的相同数据，慢内存被许多客户共享。
我们在讨论去萨克拉门托，更多的人需要去萨克拉门托，如果你不告诉我，这是个问题，也可能成为瓶颈，我们将讨论所有的法律，我想从现在开始几张幻灯片，几堂课之后，对不起，两种使用方法，要么是工作级别的并行性。
要么是所做的，一个作业分区，做不同事情的任务，所以我们之前说过，我来做最下面的滑梯，先把滑梯的底部，如果你有一个大的矩阵乘法，你可以把它分了，你在这里，我在这里，好啦，我们有十个人，你说这个专栏。
你留在这里，你呆在你的车道上，你做你的事，然后把它加在一起，并以某种方式为最终结果做出贡献，或者工作级别的并行性，你说你知道，我有很多事要做，一个是对这个列表进行排序，二是找东西，二是，我不知道。
在这里否定一些东西，或者做一些模拟，每一个，过程，核心在处理无关的问题，他们是同一个项目的一部分，也许吧，但他们在做的事情上有点无关，所以我要用这个记忆来做我列表中的事情，我正在使用的链接列表，在这里。
我的搜索是记忆的另一部分，所以我还在用同样的记忆工作，但我在做不同的事情，我们称这种工作级别的并行性非常不同，而不是我们都分享，研究矩阵，乘积在一起，仅仅分担并行处理的任务是很难的。
这就是为什么如果我真的希望我再次从幻灯片中出来，不要并行地对此进行优化，直到你真正知道你在做什么，这很难，一些人在这两个方面都写了博士学位，尝试用新语言支持并行编程，新技术，新支持，还有，那是凯西。
是啊，是啊，就像我们的一个，加州大学伯克利分校的研究主任有一个博士学位是，她有很多博士学位，一门新的语言，让它变得更容易，所以如果语言可以支持你，并行性可能会指导你，为你免费做事，那太棒了。
以及并行硬件，你怎么做某事，你如何优化最后一张幻灯片，对新算法更好一点，当两万五的时候，这是一件非常重要的事情，它被称为计算机的巨变，巨变建筑，所有人都很兴奋，算法的人很兴奋，因为现在我在想。
每个人都需要有并行算法，你如何把所有的传统算法并行处理，我们在说什么，运行时，所有的建筑师都很兴奋，所有新架构，所有的理论家都很兴奋，所以每个人在2005年左右都很兴奋，在这个部门工作真的很有趣。
这很难，并行编程真的很难，但这也是不可避免的，这是我们唯一能走的路，我们在传统的时钟调速方式上碰壁了，只是丹纳德缩放，只是等待，让系统更快，为了获得更好的性能，我们必须并驾齐驱，这就是现在的现实。
这就是我们，马离开了谷仓，我们当然都在无与伦比的，不行不行，我们要回到移动系统，我们在移动系统中看到，A14芯片有多个内核，他们现在有专门的处理器，作为运动处理器、图像处理器和神经处理器，很神奇的东西。
以及图形处理器，它现在一直在那里，你也可以好好想想发生了什么，如果可以的话，我不知道，想象一下二十年前的亚马逊，也许在一个大仓库里有一个一百万台电脑的仓库，不知何故冷却了，以某种方式互相交谈。
以某种方式支持一个大请求，比如运行亚马逊软件，想象一下，有多少独立的交易发生在亚马逊或Facebook上，或者任何社交媒体应用程序，所有这些都是并行的，只是有一个巨大的计算机房间，都在凑合。
这就是仓库缩放计算的意义所在，我们以后再谈这个，在每台计算机中令人兴奋的几节课中，你有多个节点，然后是几个CPU的盒子，当然还有明迪和西姆德，Simd本身，你在并行添加，在SIMD中浮点数。
你的计算机中有多核，所以它就像一个装满电脑的房间，在电脑里，你也有MD，宽宽，宽和和多个核心处理这些和。
我们的表演怎么样，到目前为止进展如何丹·威尔，我给了你一个小曲线，继续往上走，但让我们来看看一些数字，如果我们从两千年开始看，三年大约是二十年，伊什到二十一，十二年，让我们回到十二年前。
从两千零九年到二十一，我们见过多少和弦，所以核心有点去了，记得我说过2005年还早，这么早，现在2000年初的一两个核心，我们大约有20个核心，18岁的典型，八十，八到八到二十，伊什，有些是更高的。
一些较低的，它很兴奋，所以如果你看这里，这是生长的8到20，大约两点，五x从2000和12作为一个九到二十一，向量有多宽，记住希德，我们讨论宽向量，同时加入大量彩车，一条指令大约是八倍。
这些载体长得有多宽，如果你把它们相乘，我们看到的节点浮点大约是12年后的20x20x，神圣的动机，那是什么意思，那大约是一分，两个，一年八次，两个，8%的连年增长，也就是每三年翻一番，那太棒了。
以前我们有摩尔定律，因为我们每两年将C上的晶体管数量增加一倍，然后每十八个月加速一次，所以每18个月翻一番是惊人的，每三年翻一番，我要表演，独立的东西，一个是晶体管的数量，我看到一个是表现。
每三个两个x是一个相当好的交易，我们仍然可以用它来工作，这是令人兴奋的，但又一次，程序员必须编写并行的代码，你现在不能免费得到它，如果我们能利用它，那是。
如果我们能利用它，我们如何使用它，让我们切入正题。
如果你去你的电脑，我鼓励你有一个笔记本电脑类型，PS PS列表，您正在使用的所有流程，这是一个关于典型事情的列表，看看这些恶魔，这就是所有以d结尾的东西都是守护进程，这是一个运行的后台任务。
操作系统你想了解更多，接下来的五六张幻灯片，只是为CS一六十二做广告，这是61年的后续课程，C，了解操作系统，这是其中的一部分，这是重要的一部分，他们在一百六十二教你什么，挺刺激的，我有156个。
一次运行的总进程，您的计算机是如何管理的，太神奇了，这是我们正在做的一部分，多核处理，好啦，想象一下，在同一时间做156项作业，基本上不可能，那么它是如何与这种新的想法技术一起工作的呢，称为线程。
我第一次正式告诉你，这是一个线程，就是所谓的执行线程，它是一个单一而独立的，单指令流，你知道指示是对的，添加加载添加加载存储，好啦，想想那一连串的指令，它是一个单一的指令流。
独立于其他可以在这些核心上运行的人，一个程序可以将自己分割或分叉成多个线程，并将自己分割开来，好好说，我需要有人再次，对此列表进行排序，这里有一个线程可以搜索其他区域，你的工作是推翻和否定一些事情。
所以这些线程中的每一个都可以由您控制，程序员和他们在理论上并行运行，这是一个简单的思考方法，现在呢，这是怎么做到的？我说过这个，您可以拥有串行运行的并行软件，非并行硬件，非并发硬件，怎么可能。
这是图片分时，我做了个类比，上次我谈到这件事是在星期五，如果你有父母，你得让六个孩子睡觉，你所做的就是给每个孩子一点时间，哎呦，你是个可爱的孩子，读一个故事，一个故事，晚安月亮大一点的孩子，好啦。
太棒了，哈利波特第一章，一个大一点的孩子，你真棒，你真棒，第二册，你正在经历，在你哄每个孩子睡觉之前给他们一点爱，这就是中央处理器的功能，CPU被称为分时机，分时机是如何，顺便说一句。
当我坐在你的座位上，我真的，这是很久以前的事了，三十年前，当我坐在你的座位上，我得写一篇文章，麻省理工学院的系统是一个分时机器，所以这是一个，我们认为一台非常快的计算机，但是所有的学生都在敲。
你可以想象我把，如果越多，我问你，如果你在父母负担中增加更多的孩子，这意味着每个孩子都有更多的时间还是更少的时间，更少的时间是吗，想象一下所有麻省理工的学生都想用这个系统来写论文，因为我们都没有电脑。
所以你必须把他们的东西写在这台共享电脑上，在分时计算机上，我讲故事，至少它不相信，我记得有一天我试图写一篇文章，你知道吗，高一新生，或者以前是什么，我有自己的电脑，我在某个时候买的。
因为它们是在80年代问世的，我打了一整行，屏幕的80个是80个字符宽，我在没有看到反馈的情况下键入了整行，想象一下打80个字符，希望我能有更多的时间，它基本上是在排队我所有的钥匙，然后我们去。
它会显示80，我有一些错别字，但请记住，它去了下一个人，所以我把光标向后向左向左向左，它不动了，因为我再也没有那个时间片了，所以我必须喜欢左左左，我想是12点以前，十二背，好啦，现在是d不是x，好啦。
这是正确的，我离开了，我去了，我的天啊，这是我以前写的一篇论文，所以分时是个问题，你得到的人越多，要求关注的人就越多，如果你有一个CPU，你得到的时间越少，所以这是一个真正的问题，因此，在时间机器中。
您可以通过减少并发运行的程序来提高性能，这意味着每个正在运行的程序都有更多的时间，所以如果你在后台有幻灯片，你不用它，别再说了，好吗？别再跑了，嘿用户，如果你要去吃饭，注销，所以说。
你得不到我们曾经分享的那一点点时间，好的，好的，所以时间共享是可以实现的，事情就是这样做的，如果你有更多，如果你有更多的线程，然后核心或CPU处理了这一点。
你只要给他们一点时间，好啦，我们谈到了线程，作为执行某些任务的顺序指令流，在我们称之为程序之前，我们先打电话，我们将称之为线程，现在呢，那是个新词，对于一组连续的指令集，这些指令集碰巧做了一些事情。
这可能是更大计划的一小部分，每个线程都有，这很重要，CPU的状态是什么，如果我问你们所有人，中央处理器的状况如何？PC，所有的寄存器，也许缓存，它是记忆的副本理论上来说，但如果我们都分享那段记忆。
那我现在就不用担心记忆的部分了，所以这里呢，专用CPU和所有寄存器，这里有两个新词，我想让你明白，我的系统可以处理一定数量的线程运行，因为我的硬件，你有多少个核心，所以一旦一根线。
我想说映射到一个物理核心上，我们将称之为硬件线程，所以一个硬件线程意味着它实际上在运行，好啦，这是你悬而未决的请求，今天真正被选中参选的，现在这叫做硬件线程，软件线程是你和软件要求一千个线程。
但我不会继续，一台能同时运行上千个程序的机器，所以那些是软件线程，请求是软件线程，那些真正被锁在里面的，男孩，好啦，下面是在这个硬件上运行的软件线程，它变成了一个硬件线程，所以软件是漂浮在以太中的。
用户可以请求一百万线程，硬件线程是今天实际运行的线程的计数，这就是区别，行为，所有没有映射的，所有没有映射到硬件的，我们只是在等待，只是等着享受阳光。
只是在阳光下等待他们的时间，这是我的同事，退休教授爱德华·李，谁有这句精彩的名言，我想要，我想读给你听，只是因为它太好了，尽管线程似乎是顺序计算的一小步，事实上，它们代表着一个巨大的进步。
他们抛弃了序列计算最基本和最吸引人的特性，线程作为计算模型是非常不确定的，程序员的工作变成了修剪这种不确定性，大句，意思是线程不按顺序运行，所以你有一个正常的序列，你拿起你的手指，你说我在这条线上。
我在这条线上，我在这条线上，我在这条线上，一旦你拿起两个手指说，好啦，现在可以有两件事同时运行，我告诉你它们可能以任何顺序发生，这个可以卖20英镑，这个可以卖1英镑，或者这个可以卖二十块，这可能是一个。
取决于等待萨克拉门托，或者取决于你在做什么，所以现在你有了，你最好，确保您的输出是有弹性的，这两件事可能会无序发生，完全像这样可以结束然后去，或者这可能会上升到10%，然后这个可以是五个，然后是十个。
无论发生什么顺序，这就是非决定论，我不知道，我做不到，我不能事先决定，确定性手段，我可以事先确定，这是序列，这就是问题所在，这就是将要发生的事，那是输出，非决定论说，我无法预测会发生什么事。
我只有两根手指，想象一下你有一千条线，全部同时运行，而这一切都完成了数字线程，六号，五十五，从头到尾，你的结果支持你吗，哦不不，这必须运行笑得很好，你是怎么做到的，这就是他所说的，你是怎么管理的。
如果程序中有任何数据依赖项，在有些事情必须发生之前，其他事情，这是最难的部分，这就是为什么这真的很难，东西，这就是为什么他们的PC都是关于如何支持支持，那个空间里的程序员，所以从另一个角度来看。
一六十二，了解更多关于这些东西的信息，从用户的角度，你做什么，什么样的幻觉，什么抽象，你提供给用户好吗，您希望给人一种同时有许多活动线程的错觉，独立于实际，它们正在成为，哪些软件线程正在成为硬件线程。
你想给他们一个用户，他们都在同时运行，第一，多路复用软件线程到硬件线程，意思是这是我的软件线程，得找出哪个映射到硬件线程，这就是操作系统现在要为我做的，OS也免费为我做什么，这是一种很酷的免费。
切换出阻塞的线程，所以你去缓存缓存是快的，你可以做一个指令循环，但有一个失误，现在你得去萨克拉门托，那将是一个漫长的等待，所以当我在等待的时候，我可能会把线换掉让别人抢那个位置。
所以把那个线程从硬件线程切换出去，暂停，让别人抓住它，在那里得到一些时间，哇哇哇，同时，我还是要去，这很有趣，你如何建造，怎么做，趁我还在萨克拉门托，为未切换的线程获取数据，所以这很复杂。
你是怎么做到的，你也可以有一个计时器，你可以说，让我们确保我们给一个计时器，每根线，你认识一个，你工作的每一毫秒，然后一毫秒我就会把你换到一份，这个，如果你有一千个请求，你只是八个人中的一个。
16个不同的硬件线程，你得给其他192个，有些爱，你不能让他们等到前八名结束，所以你得把它们调换一下，因为用户又一次认为它们都在同时运行，当你形成一千个软件线程，你以为你就不能说好吗。
第二天结束时的前八名，否，那是行不通的，你必须让他们认为他们都没有开关了，你要继续，可以从硬件线程中删除软件线程，请记住硬件线程仍在实际运行，通过中断执行删除它，它是什么状态？保存它的寄存器。
并将它的PC保存到内存中，所以你只需要把它拿出来储存在某个地方，你要把它储存在哪里，储存在记忆中，所以你现在去萨克拉门托，只是为了储存线程，那个有趣的怎么样，希望这是缓存，但你又一次得到了。
这也是一个问题，然后如何开始很好地执行一个新的软件线程，如果它在你加载之前就在运行，它是以前存储的状态，它的PC机和活动物理硬件的寄存器，PC和硬件寄存器，然后把它发射上去，好啦，跳到它的保险箱里。
PC，PC是它运行的地方，电脑说你那天在做什么，那是一种计数器，当前程序计数器的位置。
所有的事情都很复杂，你会学到比1962年更多的很酷的东西，这里有一个例子，四个核心是我在旁边列出的所有过程，如果我有四个核心，我的线程列表，都在上面竞争，是我的线程池，您的软件线程在线程池中。
你把它舀起来，你对他们说你今天要去五金店，你被选中了，你把他们扔进去，将它们映射到硬件线程，好啦，每个核心实际上一次运行一个指令流，就是这样，所以让我暂停一下，在我们明白之前，我有多个核心。
我们所有人的一大池，您作为用户，这就是程序，我说用户，我是说程序员，你是程序员，我要一千个活跃的线程，我不会就这样，假设我只跑到这里，硬件中的四个并发线程，我不打算拿前四个，让他们拥有整个空间。
直到他们完成，因为可能会有很多内存访问，可能是很多无所事事的等待，因为它可能不是很有效率，因为很多萨克拉门托人，你希望能够让用户认为，他们都是千人都在跑，所以我要抓紧时间，直到他们有点失速。
把它们弹出来，去拿其他的，所以用户说，哦耶，他们都得到了一点爱，你们都得到了一点爱，就是这个意思，但是每个核心一次运行一个指令流，问题是的，是呀，这是下一张幻灯片，你的问题很好，就像你说的。
每个核心一次可以有一个以上的线程，这正是下一组幻灯片的内容，亚尼亚号，就像一个伟大的源内存，所以喜欢如何如何如何，啊哈，那么如何知道何时交换硬件线程呢，你怎么知道该拖延什么正在发生。
你知道当一张卡被缓存击中时，我们看到一条电线说缓存命中或未命中，我们知道那根电线，所以我去做一个记忆请求，这是一个缓存雾，我知道会有处罚，试着得到它，也许还不算太糟，也许只有一二可能是一三。
可能总是去萨克拉门托，所以我知道那是个小姐，因为命中率不高，然后我知道这是一个机会，让我给一些其他的时间线索，所以使用缓存命中硬件让，你知道有一个缓存命中，这可能是一个切换线程的机会，问得好。
所以核心被用来，因为它还是会消耗很多，这是个好问题，这是个好问题，嗯我们要看的东西之一我看到了这个，但你最终会消耗力量，如果你换了很多，如果你总是处于零，什么都不做，你实际上消耗的能量更少。
所以如果在理论上如果你想象，我是说，这些核心仍在计算机上工作，数百个守护进程都在运行，需要访问，所以核心闲置的可能性很低，但想象一下在堕落的情况下，你可能有一个实际上没有什么作用的核心，电脑就像。
我喜欢，我在等硬件或地图给我，没人把它映射到我身上，也可能是模特，在未来，你有更多的硬件线程可以运行，软件线程的数量较少，但目前它更多的是软件而不是硬件，但是想象一下未来，他的软件和大量的硬件线程。
嗯就像在GPU里，也许什么的，如果我醒来无所事事，我只是说闲着是的，它比大量切换消耗更少的电力，你切换得越多，你能做的力量就越大，但只有一小部分你还在，你还是，你还在消耗一些能量，所以它比较少。
但不是很多，好啦，多线程。
所以我有点导致，一个核心能同时运行两个线程吗，前情回顾2005年，我就像没有一个核心运行一个硬件线程。
你真的完蛋了，有趣的是，有一种想法叫做多线程，想法是这样的，活动线程，记住遇到缓存小姐，我们谈过，这是一个演员线程可能被踢出去的机会，所以它可能要等一千个循环德拉姆才能醒来，您可以运行另一个线程。
直到数据可用，我们很容易就谈到了你可以交换整个线程，但问题是，有什么问题，您可以保存当前线程状态并加载新线程状态，可能有很多寄存器，寄存器可能真的很宽，如果您使用大量SIMD寄存器。
你必须在不到一千个循环的时间内完成这个转换，因为如果你是如果开关本身需要一千多个循环，那你为什么要把它都换了，让我们跑到记忆恢复，硬件能帮忙吗，是呀，这就是我之前提到的，我们有很多晶体管，很多。
你能聪明地使用更多的晶体管吗，不如这样吧。
如果是你干的呢，这是一个核心，一个核心，不是两个核心，一个核心，左边的大箱子是一个核心，但是你可以在那个核心上运行两个线程，你需要什么，你得有更多的状态，整个州的移动很烦人，所以如果你有多酷。
这就是如果你只是添加了第二台PC和第二组寄存器，寄存器块很小，三十二乘三十二等于十，二十四位，这在模具上很小，里面有两份电脑寄存器，从……，这里有一件很酷的事情，我要介绍一个新词，从软件的角度来看。
它看起来和两个处理器一样，所以你想做一个抽象，你怎么告诉用户，你在下面，就像你在引擎室一样，全是汗，又热又油，就像泰坦尼克号之类的，你怎么告诉上面头等舱的人，下面真的有两个处理器，事实上。
你真的很家常有这张照片，你只有一个记忆，一个ALU，但从某种意义上说，你确实有第二台电脑，第二组寄存器，你可以假装你有两个并发的程序，只要你显然不想同时使用ALU，硬件辅助软件多线程，也称为超。
有很多这样的营销词，所以我们采用了，不幸的是，所有这些营销词他们用超线程这个词，所以如果你听到超线程这个词，它意味着硬件辅助软件多线程，这意味着这张照片，这只是一个核心。
但我们显然要对每一个核心都这样做，但这只是一个例子，理论上两个线程可以同时激活，只要他们不主动，使用ALU的人都在做，你知道的，写到相同的记忆区域什么的。
所以这是一张幻灯片，一张来自英特尔的幻灯片，展示了超线程是如何工作的，让我带你看看这张幻灯片，所以你有两个线程，红色的一根线，绿色的一根线，两根线，他们试图说明物理过程中发生了什么。
您仍然有一个物理处理器，有和没有超线程，在旧学校里没有快乐的穿线，线程一，红色的得先跑，然后绿色的会追着它跑，所以如果我考虑资源分配，这意味着您使用的是数据路径的哪一部分，缓存使用的内存的哪一部分。
你有时会看到它使用多次，但有时它是闲置的，你在等待，你在想，你看这些红色的方块，这里有很多蓝色的空块，另一个程序可能使用，如果我能弄清楚程序的顺序，也许我们用的另一个东西是无序执行。
也许你可以把幕后黑手弗雷德，但实际上拥有它，向前跳，并尝试重新安排一些硬件乱序执行中的教官，所以我的想法是，顺便说一句，你可以做到这一点，最大限度地减少我们在你的管道中谈到的停滞，或者你可以尝试优化。
您的超线程系统有多最佳，所以这个绿色的线，而不是等到红色的都做完了，实际上可以同时运行，如果你聪明点，也许一个小的重新排序，也许这就是编译器的工作，也许是在硬件上动态的，你在巧妙地移动这些。
也许这边有一个，但你在想怎么才能穿上绿色的，完成它的工作，吞噬所有空虚的忧郁，所有的忧郁都是空荡荡的，如果网格需要这些人，你真的可以让它发挥作用，所以它并不完美，意思是你不会总是得到两倍的进步。
但你实际上可以接近它，挺凉快的，所以我的想法是，同时多线程或超线程，意味着现在我们必须引入逻辑CPU的想法，有一个物理CPU说，你有多少个核心，那是物理CPU，逻辑是你能伪造多少。
你能告诉机舱上方头等舱的人，在泰坦尼克号上你有，我们将称之为逻辑CPU，因此每个线程在每个核心同时运行多个线程，我们说这是我在最后一张幻灯片中展示的艰难方式，每个线程都有自己的体系结构状态，PC寄存器。
等，您可以适当地共享资源，有一个完整的网站，对称多任务处理，多线程，对不起在华盛顿网站，我给你那里所以。
对这些逻辑意味着什么，现在我们要谈很多话，逻辑线程，你有一个硬件线程和软件线程，但现在你实际上有了这些逻辑线程，在逻辑CPU上运行，再多一点硬件，看那个，大部分硬件都是一样的，我是说。
我所做的只是添加了一些PC和一些寄存器，那只不过是，很酷的硬件，也许性能提高10%，因为这真的很难做到，有时候如果你真的是最佳人选，你可以得到几乎两倍的性能，但它非常，你知道的，我是说大约10%。
我们在这里，多核逻辑线程，所以这种风笛穿线不会给你一个两个X，但你知道在一个堕落的案例中，也许很接近那个，但大多数时候它都这么做，但还是更好，多核实际上有重复的处理器，重复核心，再多一点硬件。
但不是不去X更多的硬件，增加50%的硬件，和大约2倍的性能，如果他们独立工作，做得很好，所以说，如果你把它们结合起来，我们可以做得很好，机器对两者都有好处，我给你看一张照片，这就是我的电脑。
我把它装起来，我这里有最后一台笔记本电脑的号码，我不得不在最后一分钟改变它，如果我说是控制硬件，我有张单子上面写着，基本上我在戳硬件，说着，跟我说说你自己，硬件先生，你真可爱，嗨，我有八个物理CPU。
但我也支持十六岁，我也支持这个宽SIMD，它将告诉你的一切，所有这些都是为了了解情况，逻辑CPU，十六八核，16个线程可以同时运行，所有的一切都在那里，乔拉尼娅有个问题，这就是所有的操作系统，问题是。
谁决定映射操作系统是在超线程的最低级别上完成的，可能是硬件造成的，看说明书，说着，哦，我可以在这里做吗，也许我可以把它们重新排列一下，但不要太多，那是在较低的层次，但在软件层面是映射软件线程。
操作系统的工作是映射软件线程，到硬件线程，但在超线程的最低级别，那是最低级系统的工作，你不需要为他们担心，你可以考虑一下，嗯，我有16个核心，我真的没有，我有八个，但因为这些合乎逻辑的座位。
但我当然可以得到更多的表现。
好啦，来看看那个，让我们，让我们实际上，我是说，只是为了告诉你这是真的，这是英特尔W，就像，这是一年半前的幻灯片，但是天气很热，很新的花哨的机器，W3275m处理器，你能得到多少规格表。
我想在这里强调的规格是什么，核心数，你从后面的号码看不到，当然啦，上面写着28，线程数，前排写着什么，五十六，这就是超线程五六线程的想法，你可以在两个八个物理核心上同时运行，这是一个大的。
我们说的是效率，我们谈到了效率，我们谈到了性能，有一种他们称之为热设计功率的东西代表了以瓦特为单位的平均功率，处理器消散，我们在基频上工作，在英特尔定义的高复杂性工作负载下，所有核心都处于活动状态。
请参阅数据表，我的朋友不是移动设备，那不是移动CPU，这是一个需要，那应该放在你桌子的一边，拿着大扇子，把热量弄出来，两百瓦很热，好啦，那是件大事，这不是移动设备，但这是一个强大的。
不带囚犯性能驱动CPU五六逻辑线程，对于任何CPU问题都令人印象深刻，是呀，告诉我你的名字，走呀，走呀，现在有什么有趣的问题，也就是，哦男孩，我不是CPU设计师，但他们有点，我来猜猜。
它是设计师的一部分，一种新型CPU的制造设计，它需要一吨，我这么说是为了建立一个新的，一个新的晶圆厂，一个新的制造实验室，以新的工艺尺寸工作，工艺尺寸，在特定芯片上的两根电线有多小，我听说这是岩石定律。
就像10亿美元用于新的，这就像，你得在如何做到这一点上投入这么多，那么如何制造，那里有很多工程困难，设计也有挑战，因为当你把电线拉近时，你最后会说相声，还有其他元素你带来的东西现在很好。
这是一个坚实的一和一个坚实的零，现在他们有点，这将是一条高频线路，现在这是在翻转，什么的，有一些问题，当摩尔定律继续推动你时，能够有越来越小的工艺尺寸，很多物理学，很多量子物理学都在思考如何做到这一点。
原来你是这么想的，在过去的设计中，你根本不在乎，现在设计必须关心这一点，但你必须通过建造它来实现它，所以我想说我想说谁会赢，有一大堆困难的工程对话要进行，在它的设计和制造中，这是个很好的问题。
很好的问题，这里有一个关于一个特定系统的例子，该系统可能有六个核心，每个核心能够处理四个线程，假设你的系统里有超线程，同时可以做四件事，理论上，每个核心可以有四个逻辑线程，对于24个逻辑软件线程。
挺酷的。
好啦，所以在我点击之前定义最后一张幻灯片，我喜欢这个点击问题，我想让每个人都插话，我们有时间做最后一件事就是复习，以下是一些定义，我们今天看到很多词，但希望不会太糟糕，一个头号线程，最重要的是。
这都是话题，这叫做线程级并行，我们说的是连续三堂关于威胁级别并行的课，但不知道什么是线，它是一系列指令，你以前叫它程序，我们称它为有自己的程序计数器和处理器状态的线程，例如，多核寄存器，是我们所看到的。
我们已经走了，我们知道为什么我们在2005年运行多核，你知道现在物理CPU的动机，它说每个CPU和软件操作系统开关一次处理一个线程，线程，通常是对碘事件的反应，就像磁盘读写或缓存中的内存丢失。
逻辑CPU允许在硬件中进行更细粒度的线程切换，用线程块，也许是缓存错过了超线程，也称为同时多线程，SMT允许超标量体系结构，超标量意味着多件事可以同时发生，体系结构支持在同一时间从不同的线程启动指令。
在法庭上的同一个CPU里，好吧，我们开始吧，这是整个系列到目前为止最好的问题。
我喜欢这个问题，这让使用多核计算的软件和硬件设计师最头疼，好啦，所以我得到了电脑的五个部分，你以前见过，希望你能通过心脏控制，数据路径，内存输入输出，哪一种最头疼，因为我们现在已经走了，两千零五年。
就像，诅咒你空白，你在这里放的空白处是什么？诅咒你输入，诅咒你的数据路径，所有的软件和硬件设计师的针是什么，因为我们现在在这个CPU多核的世界里，称为控件的控件，逃跑，数据路径有一点动作，到目前为止。
没有人喜欢产出，如果我是个赌徒，我想说我现在喜欢控制记忆，但让我们看看这里会有什么，我们能得到更多的爱吗，更多的人投票，我不会的，我很想看到每个人都投票，包括在线的人，如果你在线，你还可以用这个。
只是提醒一下，文本ddg到二二三三三或polevy。com，砍DDG好吧，所以这里有点稳定，我们再去弄点来，好啦，有人想立案吗，为什么他们认为记忆是这样，你可能想，这里谁勇敢，亚当告诉我，为什么是记忆。
这是瓶颈，内存是共享资源，您有一个共享资源，这就是烦人的地方，丽莎和我很高兴能一起讲课，但只有一个遥控器，我们正在抓住它，我做了一个特别的市场，她不喜欢市场，我们不喜欢这样。
所以这是百分之百的记忆伙计们，它是共享资源，你们这些人，三分之二的人说干得好对你来说很好。
一张滑到这，总之，我们今天学到了很多，顺序软件执行速度有限，时钟速率持平或并行度下降，高性能要素，辛迪更宽，我们看到Mimi是线程级并行的向量，现在你知道MII中的M是什么意思了，医学博士是多个数据。
MI是多个指令，那是让我们学习的线索，这个情报有2个8 4 5 6线程，主要挑战，多进程高性能并行程序，随着数字进程的增加，那是规模。
我还有最后一个开始给你，这是记住今天的万圣节，祝你万圣节快乐，诡计，Xor治疗是正确的措辞，你可以随意纠正，每个来你家的孩子，但在捣蛋和请客之间，这里有其他逻辑操作的选择，尽情享受吧。
P39：Discussion 10： Multi-Level Caches, AMAT - 这样好__ - BV1s7421T7XR
今天大家万圣节快乐，呃，继续我们上周开始讨论的内容，进入一个更详细的主题，所以这几乎意味着我们将讨论缓存和缓存性能，一点物流，就像你们在，Ed，期中考试成绩出炉，呃，降级申请本周五截止，请提交请求。
即使你不确定你是否能拿回分数，如果你对这次考试后的感觉有任何问题，请随时联系我们的学生支持助教，愿意帮助你的人，实验室吃了这个星期五到期，它涵盖了并行性，我们会在这周的课上讲到，在缓存中的家庭作业七。
本周三到期，与周一相比，这是一个不同的步骤，项目3b下周三到期，所以正如我今天早些时候所说的，我们将在很大程度上涵盖不同类型的缓存，呃，更像是我们上周开始讨论的内容的延续，除了聊天，如果我们有时间。
我们将讨论缓存性能，或平均内存访问时间，我还想在这里强调的一件事是，如果您有兴趣在缓存中获得更详细的信息，我们的一个负责人写的课程笔记，卡罗琳太棒了，我强烈建议你们调查一下，所以一点点记忆，一点点回顾。
我们需要缓存的原因是我们希望主要关注以下内容，空间位置和时间位置，这意味着如果你知道你将访问，嗯，在记忆中彼此接近的记忆点，然后我们想让它更容易，所以你可以很容易地从记忆中快速获取一些东西。
所以缓存对空间局部性和时间局部性都很好，如果你知道你要抓一个类似的物体，以后，你不想浪费这么多时间去买每一件东西，每一次，缓存非常适合时间局部性，会不会嗯，因为我们可以在缓存中存储我们最近使用的项目。
然后我们可以继续从它身上拿走，正如我们从缓存访问周期时间中看到的，我们知道嗯，我们的循环时间来获得我们的时间，从l 1缓存或l 2缓存中获取项目，比物理内存访问要短得多，甚至一万，好啦，然后一点点词汇。
所以我们有一个叫做缓存线的东西，几乎是一个街区，它将我们将要访问的所有内存存储在缓存中，我们的布景，它是缓存行的数量，并形成一个更大的组，您仍然可以索引，当我们讨论n集联想时，我们会更深入地讨论这一点。
然后关联性是高速缓存行的数量，或再次形成集合所需的块，这将在我们讨论不同类型的缓存时讨论，然后呢，Evict是一种用于实际删除缓存行的策略，或者用缓存中的其他内容替换它，我有吗，哦，我们开始了，是啊。
是啊，所以在这里，呃，下面是我们使用的不同类型缓存的一些示例，我们有我们的直接地图缓存，它的结构是这样的，我们有我们可以存储我们的标签，我们知道我们将使用什么索引，在这种情况下，用一张直接的地图。
每个块是一个索引，所以第一行是零，然后一个，然后两个，然后三个，然后嗯你，我们有一个完全关联缓存的数据，没有索引，您不受um缓存地址索引的限制，你只需要有唯一的标识符，好啦，如果这是标识符。
我们可以继续看这张幻灯片，然后对于n组关联方式，在这种情况下，我们称之为双向联想，我们称之为双向联想，因为一套两个方块，不是这两个，不是这两组方块，每套两个块，然后它的作用很大程度上是我们有。
我们还有标签和数据，我们仍然有我们的索引，但在本例中，我们只需要a来支持两个有效的索引，零和一，因为呃，这是一个双向集合关联，因此，我们将有两个块到两组两个块，所以只有0和1，我们谈过的一件新鲜事。
我们还没机会和你谈谈，上周是正确的政策，我们实际上，我想我以后再讨论这个问题，但是是的，所以稍微休息一下，标签回顾，索引和偏移量，所以标签，正如我前面提到的，是缓存行的唯一标识符。
这是内存地址的第一个t msb位，然后索引几乎是指定集合数索引的位，所以如果它是一张直接的地图，只是每个块的索引，或者如果是，或者如果它是一个集合联想，然后是每一组的索引，这是下一个我MSB位。
然后进去，然后最后的oh msb位将用于存储偏移量，哪些是索引，这就是如何在一个块中索引以获得我们想要的实际数据，这取决于块的大小，我们可以看到，通过我们在这里的计算，所以对于我们的抵消。
我们看到它等于，我们可以计算出偏移量所需的位数，通过取原木底座，两个我们的街区大小，我们可以通过得到集合的数量和日志来获得的索引，两个那个，在这种情况下，它正好等效于缓存大小，除以相关相容性乘以块大小。
然后剩下的出价我们会攻击到目前为止的任何问题，所以我们之前想问的几个问题，我们实际上进入了什么时候，我们实际上需要计算一下，但是在哪里使用了多少位，每当我们需要喜欢的时候，使用现金演示。
我们需要回答以下问题，我们的物理内存大小是多少，我们的缓存大小是多少，我们的街区面积是多少，所有这些都可以用来寻找，缓存地址中需要的不同比特数，然后我们需要我们的现金组织方案。
如果它是完全关联的或直接映射的，或设置联想，因为这就决定了我们将如何以某种方式驱逐，这将决定我们如何从缓存中驱逐块，然后我们需要知道我们的驱逐政策是什么，我稍后会更详细地讨论，关于不同类型的驱逐政策。
然后我们需要得到每个，而且是的，这正是我们现在需要问的问题，作为一点回顾，我给你们几分钟，呃，就像一两分钟来回答下面的问题，是关于现金地址的，比如计算比特，好啦，所以让我们进入这个。
所以我们知道我们的缓存大小是32位，然后每个块大小是8字节大，呃，在这种情况下你会有多少块，然后呢，有人想回答这个问题吗，完全正确，是啊，是啊，所以我们将有四个位作为可能块的索引，呃，对于块。
那么这意味着我们实际上需要得到多少比特，实际上得到我们的索引，两个正好，是啊，是啊，所以我们要做4个对数中的2个，等于两个索引位，现在是三点二，我们需要知道我们想找出我们的标记和偏移量位是什么。
我们先从我们的偏移量开始，所以说，作为我们的补偿，我们需要知道我们的街区有多大，我们的块有8字节大，那么我们需要多少位作为偏移量位，准确的说是三个为什么如果我们做日志记录，八个中的两个，我们会得到三个。
我们做日志二的原因是如果我们有一个，在这种情况下，如果我们有一个三位偏移量，那么需要发生什么，有三个比特，对于我们可以寻址的字节类型，我们有八个可能的选项，因为这是字节可寻址的，在那里效果很好。
最后是我们的标签，我就这么做吧，所以如果我们知道我们有一个3位2位的地址，我们知道我们有两个索引位，然后我们知道我们有，然后我们知道我们有三个偏移位，等于三二减五，这等于两个七个标签位。
这是一个很大的标识符，但是是的，有人对此有什么问题吗，呃，所以对于偏移量，我们有三个比特，呃，我们在这里使用八个字节，所以我们是不是应该做很多，呃，呃八点，这是一个字节可寻址缓存，没有一点地址，我们是。
呃，系统通常是字节可寻址的，位不可寻址，我们只想得到这个，我们只想寻址每个字节，不是每一点，所以这就是为什么我们只关心八个字节，还有其他问题吗？让我们继续前进，所以说，正如我前面提到的。
我们需要考虑的一件事，每当我们使用缓存时，我们的驱逐策略，还有一对，有很多，但我强调的那些是最重要的，最近在FIFO中使用最少，所以FIFO意味着驱逐，队列中集合中最古老的块。
如果我们把它表示为一个队列，所以几乎，假设您在缓存中总共有三个块，你想插入一个b，C和D实际上，我们想用这个访问令，我们接下来要做的是简单地把它作为一个b插入，C，我们不需要插入b，因为它已经在里面了。
我们想驱逐我们片场最老的街区，我们想继续，然后嗯，删除添加到缓存中的第一个块中最早的一个，在这种情况下是一个，所以我们去掉它，用d代替它，然后至少最近用的，我认为这是一个更好的例子，如果我继续用这里。
嗯，我们想驱逐片场的街区，这是以前最古老的访问，不是添加的最老的，但最古老的通道，在这种情况下，我们会，我们仍将按以下方式插入abc，然后现在我们看到我们再次访问一个，所以最初我们的订单是。
是一个B C，但因为我们摆脱了，但是因为我们访问了一个，我们把a从最小，然后我们把b c移到后面，然后A成为我们最近使用的，最后，如果我们需要驱逐一个街区来存储D，我们必须看看我们最近使用最少的。
在这种情况下是b，所以如果我们去掉b和d，我们已经成功地使用了lru，或者至少最近用于驱逐适当的块，然后很多人都问，哪种驱逐政策最好，因为有时候你可能，因为我们想知道理想情况下什么是最好的方法。
驱逐最好的街区是什么，这样我们就不用一直往内存里加东西了，等等等等，最好的驱逐政策并不存在，或者从技术上来说是的，但这超出了这门课的范围，嗯，会是什么呢，究竟什么才是最好的，效率，可靠性，最简单的实现。
这真的是主观的，我们将如何定义我们最好的驱逐政策，所以是的，我们真的不能在这里定义最好的一个，呃，关于驱逐政策的任何问题，嗯那么嗯，在缓存轴上会发生什么，啊，我们要谈的原因。
我们将进入一个实际使用这个的例子，所以稍微注意一下这个是很好的，至少我们要做的第一件事是将缓存地址分解为tio原则，所以拿上我们的标签，然后我们的索引位，我们的偏移位，然后你就进去了，一旦我们得到索引。
我们将继续前进，在适当的索引去片场，所以如果他们是，然后如果在那个条目上，它是一个有效的条目，意思是我们可以接触到，我们可以通过适当的标记在索引中访问一些东西，那我们继续，我数到三，其实等一下。
我们将继续进行这一部分，否则我们就得，呃，将数据块加载到内存中，所以这就是我们的逻辑，然后有很多子集我们要做，如果缓存中有有效项，我们必须，首先呢，比较我们在单独标记中的标记，现金或税金现金。
如果它真的存在，那我们就继续，既然我们已经知道了偏移量，我们只需按n个单词读取数据，然后返回，然后如果我们没有它，然后我们需要，如果我们没有合适的标识符标签，我们确实有空间可以放在我们的索引集中。
然后我们继续，将数据块从内存加载到缓存中，如果没有，然后您必须使用适当的驱逐策略来踢出缓存行，然后继续从里面加载，现在在，啊，是呀，呃，所以如果我们有两个缓存，一二，如何从l访问。
l 1如何从l 2进入，嗯，差不多吧，嗯，就是这种过程有些重复，所以如果标签不存在，然后我们就去找L 2，如果它不存在，那我们就得从财政记忆中提取，是啊，是啊，但我的意思是只有标识符和高度任务。
但我怎么能从我读到喜欢，但是呃，我不知道它是否能从，就像从记忆中读到一样，或者不是，你对此有答案吗，我不需要其他问题，对不起，你能读一下你的问题吗，所以如果我们有两个缓存，我们的A和for怎么能，呃。
这里的低保政策是什么，哎呦，我们要多报道一点，当我们开始缓存一致性时，当我们谈论多个缓存时很有趣，但基本上有一个总线连接不同的缓存，他们可以通过这种管道发送信息，把这个问题保留到我们。
我想是第11次讨论，我们会涵盖很多现金一致性，是啊，是啊，问得好，好啦，现在呢，呃，我们讨论了几个场景，其中呃，我们无法访问缓存中的有效数据，这将被认为是所谓的缓存失误，有三种缓存丢失，你们需要知道的。
我们有一个强制性的小姐，我们试图在我们的缓存中查找，而且数据在任何时候都没有被添加到缓存中，无论如何，所以我们必须把数据添加到缓存中，所以这将被称为强制性的Remus，那我们就有冲突了小姐。
因为在这种情况下我们必须驱逐，我们必须替换现有的块，否则我们就得驱逐一个街区，因为它，啊，我们要更换一个方块，因为另一个街区取代了它，如果它是完全联想的，不会失手的，等我们满员了再谈，但是是的。
它几乎是在驱逐一个街区，因为另一个街区取代了它的容量，但是，嗯，这是一种相同的冲突线，但我们实际上能够，这有点像，假设我们有一个嗯ABC的例子，然后是一个，所以如果我们加上a和b，这么说吧。
我们的驱逐政策是先进先出，我们将继续驱逐A，把C，但如果我们想，呃，如果我们想得到一个，因为A不见了，在这种情况下，我们必须移除B，因为那是我们最老的，在我们的缓存里，然后用一个。
现在这将被称为容量错过，因为，假设我们的缓存中有更多的块，然后不得不替换的小姐，然后神话必须放置一个，C就不会发生了，所以这就是为什么它被认为是，这几乎意味着如果您要增加缓存大小，那就不会失手了。
有人对此有什么问题吗，嗯其实，我需要继续删除这里的一大堆东西，你们什么都没看到，对不起，呃，好啦，是啊，是啊，所以我们会继续，我们会走过这个，第一个例子，我们如何使用缓存。
关于这个缓存需要了解的一些事情是，它是一个双向集关联，我会把它画出来，会是什么样子，因为我们知道这是双向集合关联，我们知道每一组都有两个方块，我们可以很容易地考虑这样一个集合和集合零，然后这一套呢。
然后我们有一个八位地址空间，这将帮助您计算每个地址所需的位数，地址的每一部分，所以标记索引和偏移量，我们知道我们的缓存有八个字节块，和三个字节的缓存大小，这也应该是，这也有助于计算，呃。
缓存压力的tio分解，我给你们几分钟，至少工作一半，然后我可以走过去，只要我需要，呃，那个呃，我想他们忘了在这里更新，驱逐政策是，所以有一件事我建议你们，这里有一些lru位检查。
不管是最近使用的还是最近使用最少的，使用您喜欢的任何术语，好啦，让我们开始复习这个，如果你们没有机会完成所有的事，呃，别担心，但让我们继续，第一次休息，获取我们的标签索引和偏移细分。
所以考虑到我们使用的是一个8位地址空间，我们知道这是我们得到的位数之和，对于标记，索引和偏移量应为8，有人想给出他们的答案吗，为了崩溃，好啦，我觉得我能挺过去，呃，我们可以先计算我们的偏移量位。
因为我觉得这样更容易理解，呃，我们知道呃，我们有，嗯，我们有八个字节块，所以这直接建立在我们前面所做的问题的例子上，我们知道我们需要三个偏移位来表示一个8字节的块，所以我们将继续在这里这样做。
然后在这里为我们的，因为我们知道这是一个双向集关联缓存，我们有四个街区，我们知道我们只有两套，因为只有两种可能，我们需要取两个的日志，日志库，两个中的两个，在这种情况下，所以只有一个索引位。
最后我们有了我们的标签，所有的剩菜剩饭，这些是我们的MSB位，所以在这种情况下，我们只需要四个，因为我们知道我们有一个8位地址空间，现在我们可以继续快速地将这些地址分解为它们的tio，崩溃。
所以在这种情况下，我们的时间就是，然后零和一个零零，最后归零归零归零一归零一，然后呢，我就喜欢，就目前而言，我认为这应该足够了，我们会调查这件事，所以差不多现在我们要开始用我们的现金。
所以我们需要做的第一件事是查看我们的索引位，因为我们知道它的指数是零，我们需要看看我们的第一盘，然后差不多呃，我们需要检查我们的标记是否在like缓存中的任何地方，在这种情况下，嗯，零，零，零不在那里。
所以我们需要做的是把这个，我们需要做的是添加标签，零零零然后呃，因为这是lru，哦，我会继续，并设置lru位在这里是一个，因为那是我们最近用的，然后另一个块就会变成零，因为那是我们最近用得最少的。
我们根本没用过，然后我们会我们会，这将是一个烂摊子，因为以前缓存中不存在这个，但有没有人想回答，这将是强制性的，义务教育，是呀，为什么这是强制性的，以前储藏室里没有这个，所以是的，好啦。
然后我们继续看我们的下一个现金地址，它的标签是零零零，在指数零处为零，偏移量为1-0-1，如果我们看指数0，就像我们第一盘一样，我们有一个标签在零零零零，因此，这将是一个成功。
因为我们有匹配我们想要的现有数据，然后我们就有了下一个地址，也就是1 1 0 0，在索引1上标记，偏移量为零，现在如果我们去索引1，我们将看到那里实际上没有数据，这意味着我们的标签不会在那里。
这意味着我们需要将标记添加到这个缓存中，所以零一零一，我们的lru，在这种情况下，将被设置为1，因为这是我们最近使用的，然后为另一个未使用的块为零，在这种情况下，这将，我只是要继续说。
这是一个强制性的错过，因为我们没有这个，呃，呃，我们缓存中的数据，嗯，然后我们继续看一个一个，零，零，在这种情况下，嗯，嗯，这将是一个指数与偏移量为零，零，零一一，零，零标记不存在于索引一的缓存中。
所以我们会继续补充，所以应该是1 1 0 0，现在这实际上成为我们最近使用的，所以这将成为一个，我们的第二个块的lru位将是一个，第一个方块是零，这也将是一个强制性的错过，然后我们进入以下内容。
我们有了下一个地址，它是一个带有索引1和偏移量0的标记，我们有一个我们有，如果我们去索引一，我们看到我们有一个标签，我们有标记0 1 1 0，在这种情况下，这将是一个成功，因为我们有现有的数据。
然后我们继续看下一个，也就是指数为1的，以一零一作为结果，哦耶，啊，顺便说一下，我忘了做的一件事是我们这是我们最近用过的，因为我们最近访问了它，如果我们去，如果我们看这里，指数1。
我们将看到我们的集合目前没有一零一，因此，我们需要清除这个集合中最近使用最少的块，在这种情况下是1-1-0，在这种情况下，我可以继续，很容易地把它替换为1-1-0-1，然后因为这是我们最近访问的。
我们将继续，把它改为1，把它改为零，这将是一个，你可以称之为强制错过或冲突错过，我们就把它叫做失手，因为我不想看到任何错误的信息，好吧那我们有，嗯我们的下一个地址，指数为零，偏移量为1。
然后我们看到我们没有，嗯这里的偏移量，我们没有补偿，或者我们的索引零集中没有标记，所以我们继续加0 1 0 0，然后我们改变我们最近发布的最近使用的位，这个变成1，这个变成零，这就成了强制性的小姐。
应该知道嗯，这可能是一个强制性的失误或冲突MIA，强制优先购买权，好啦，这是强制性的，根据定义，是啊，是啊，我把它放在这里，它隐藏着冲动，嗯是的，是啊，是啊，所以我的意思是，在某些情况下。
这可以被视为强制错过，或者这里错过了冲突，我们是嗯，驱逐权，但我们的现金以前也没见过这种情况，所以因为我们的缓存没有看到数据块，这是自动强制的，嗯是的，我真的很喜欢第二次，那将是，它，是啊，是啊。
所以如果我们的现金看到了，但我们要驱逐一些东西来为它腾出空间，那就会有冲突，是啊，是啊，是啊，是啊，现金是多少，有元数据，有很多事情要做，我们不会教你在缓存系统，我们从很高的水平来看，但是是的，本质上。
您可以将其视为缓存，跟踪已经访问的内容，更多的现金，是啊，是啊，我会，我会去看看，一五二就够了，哎呦，具体包括什么，P喜欢深度缓存系统，深度缓存系统，六十二并不深究太多，嗯，我没有拿152。
所以我不知道什么是好的水平，但如果你好奇的话，我会调查的，是啊，是啊，如果我们查一下最近的两个地址，我们有标签，归零归零和指标归零，我们有我们有合适的标签，所以在这种情况下，它将是一个热门。
然后我们有最后一个，它是一个标签，一个一个，指数1为零，如果我们继续看这里，我们实际上没有，我们的布景里实际上没有这个标签，所以这将是一个错过，现在我有个问题要问你们。
我们以前在我们的索引中看到过一个零吗，所以这一定是冲突失误还是其他类型的失误，记住我们这里有三种失误，我们有我们的强制性冲突和能力，会不会是，这不是强制性的冲突吗，我想是冲突，但我会把，因为好吧。
所以呃，它的动作，呃，让我继续说，答案是一个容量小姐，它是电容炎的原因是记得我之前说过，当我举这个例子时，如果我们有两个街区，如果我们有两个块缓存，使用以下访问模式，a b，然后我们驱逐a把c。
然后我们驱逐B来放置一个，我们注意到，当我们不得不把一个背部，我们知道在某个时候存在于缓存中，这将被认为是一个电容失误，因为如果我们把缓存的大小增加到三个街区，我们不一定要驱逐一个移除，呃。
我们不一定要驱逐我们的A街区，会留在缓存里，如果缓存更大，那将是一个成功，但在这种情况下，我们的缓存不够大，所以我们不得不错过早些时候被驱逐的机会，当我们稍后访问它的时候再把它放回原处。
所以这就是为什么它是一个容量，如果剩下的钱是空的，如果剩下的钱是空的，除了那个索引和喜欢，让我们说，就像下一个零打开了，没有满满的烂摊子，但你没有地方放，因为不管是不是现在我想是的，我想这听起来是对的。
但我不太确定，如果我是诚实的，嗯对不起，我在聊天中回答问题，我喜欢在两个问题之间，但我没听到你说，如果您有关联缓存，或者我想就像就像，就像适当的能力，嗯，如果剩下的现金，但就像，现在就是这样，双向关联。
不会造成冲突，这个是为了把它抓到碗里，但是，从某种意义上说，嗯，我们按顺序追踪所有的入口，然后嗯，我们，因为这有点像人造术语，就像一个真实的物理系统，这些是识别某些失误的方法，所以有一点灰色地带。
你发现了那个灰色地带，所以谢谢你问这个问题，其实真的很重要，但是嗯，如果我们跟踪访问的轨迹，并像我们的关联缓存一样行事，是一个完全关联的缓存，往那边走，我们可以把积木扔进去，直到它满了，是啊，是啊。
然后呢，如果你说的重点，如果我们的完全关联缓存在这一点上是满的，那么这将是一个冲突小姐，这就是它的分类，丹就是这么形容的，我也不确定，是啊，是啊，嗯是的，因此，冲突未命中对应于缓存中仍有空间的情况。
嗯是的，完全正确是的，所以基本上这场冲突错过了一个结果，更多的是让你喜欢，是啊，是啊，是啊，是啊，完全正确是的，是呀，所以有权衡，完全正确，嗯有道理，突出这个，因为是的，就像你说的。
我们肯定可以增加联想性，以减少冲突失误，甚至指责改善置换政策，但是是的，再次耶，这是一个电容，因为在特定的场景中我们有一个，一个，零，零，但那必须被驱逐，所以我们把它放回去，这是一个电容。
对此有什么问题吗，好啦，我想在这里谈几件事，那是呃，我们有一些我们之前说过的东西，是专门错过的，在那里我们不需要写任何东西，让我们谈谈我们需要做的政策，如果我们必须写一些东西，所以在这种情况下，嗯。
我们有两种缓存在这里这里，穿过去再回来，当我们有一个写通过缓存，这几乎意味着，每当我们需要写东西的时候，或者在这种情况下可能，写东西的一个很好的例子是使用存储词函数，一个储存词指示和风险井，会发生什么。
首先我们要把它写到缓存中，然后呃，我们实际上会继续，然后把它写在物理内存中，还有，专门针对右后卫，事实上，关于这一点，有几件事要说的是，它非常，实现起来非常简单，因为它涉及到。
只需遍历直到到达物理内存并在那里写入数据，而且效率也很低，因为我们有缓存的原因是因为我们不想有，我们希望限制对物理内存的访问，因为这需要很长时间，这就是为什么它的效率很低。
因为我们每次写都要访问物理硅存储器，然而，它要多得多，简单多了，实际上更有效率，因为我们仍然有，呃，我们仍然会骑着东西去我们的缓存，但只有当我们需要驱逐某个街区时，我们将继续。
然后将缓存中的任何内容写入物理内存，为了判断块是否被修改，我们是否真的需要把一些东西写进记忆中，我们有一个元数据位叫做脏位，等于1，如果它被修改或等于零，如果没有修改，如果是在一个，那你就去吧。
然后当我们需要驱逐街区的时候，然后我们就把那个块写到物理内存中，然后嗯，这其中很大一部分是，这比直接穿过去更有效率，考虑到您在很大程度上是为了回写缓存而编写的，除了有一点你实际上必须写入物理内存，然后。
嗯，一个大的骗局是，它很难实现，呃，进入硬件，实际上，改变大故障可能有点棘手，我会稍微处理一下，但是是的，还有一些政策，呃，然后我们终于在缓存周围写了，如果我们需要写一些东西。
我们只是直接把它写进物理内存，我们根本不用缓存，然后我们，如果我们的缓存中有一些旧数据那就不一样了，如果我们必须写入旧数据，那么就会失效，那是用，它使用元数据，当我们有一个正确的失误时，有两个政策。
作为我们的义务小姐，所以有两种方式可以发生这种情况，这可能是一个正确的分配策略，在这种情况下，我们需要从物理上提取一些东西，我们需要从物理记忆中写出一些东西，我们实际上是从数据中提取内存。
然后我们在缓存中写入，在缓存本身，然后我们会使用某种类似于写回政策，通过政策来决定接下来会发生什么，不管我们是否写入物理内存，然后我们有一个写分配策略，也就是说，如果我们有我们的。
如果我们有无权分配的政策，也就是说，如果我们有一个书面失误作为我们的强制性失误，我们只是直接将数据写入物理内存，我们不会将任何内存拉入缓存，好啦，呃，我们没有太多时间来讨论这个问题。
但我确实想碰一点阿玛特，所以阿玛特，呃，代表平均内存访问时间，我很快就会写下来，平均内存访问时间用来测量，平均来说，有多少，需要多少时间，一般来说，我们希望我们的目标很低。
这在很大程度上取决于我们每个人的命中时间有多大，错过率和错过惩罚现在是计算的公式，瞄准的是命中时间加脱靶率乘以脱靶点球，这些术语中的每一个都意味着，以下命中时间是访问和加载缓存所需的时间，一个字一个字。
一个很好的思考方式是，假设我们实际上，呃，假设我们在这里有一个缓存，然后如果我们在这里缓存，然后如果我们真的有我们的数据在我们的缓存中，那就算成功了，然后我们把我们的命中时间。
只是我们实际访问缓存中的数据所需的循环数，我们的吝啬鬼，另一方面，另一方面就是，我们在缓存中找不到数据的时间百分比，然后我们必须把它乘以点球失误，这是实际访问更多，一种内存或另一种缓存，也许是错过了。
所以在这种情况下，对于错过惩罚的单级缓存，只是访问内存所需的时间，然后对于多级缓存，你必须做一些递归瞄准，在那里它变成了这样，如果我们想让我们的将军，我们可以说这等于1次命中，这么说吧。
我们现在有一个两级缓存，加上我一个错过率，然后我们需要继续，实际上得到L 2的地图，在这种情况下，它将成为L两个命中时间，是啊，是啊，所以这一点很重要，我想我们是时候，我想我们没有足够的时间来讨论这些。
Mac电脑，几个Mac问题，所以我想我们今天可以把它叫做讨论，是啊，是啊，如果你们有什么问题，随便问吧，或者你现在就来找我们，是啊，是啊，谢谢你，每个人都有一个伟大的万圣节，其他问题，所以制片人。
我们有，呃，三种不同，三个不同的，哎呦，三次不同的失误，是呀，是呀，我会回到那个，增加尺寸可以。
P4：Discussion 1： Number Representation - 这样好__ - BV1s7421T7XR
好啦，很抱歉，卡尔教什么，Cal Teach辅修K12的数学和科学教育，所以是的，考虑到这一点，呃，我们将讨论一些关于6-2-1-C，以及讨论将如何进行，所以讨论完全是可选的，出勤情况不会被追踪。
我们鼓励您尝试不同的部分，正如我们所知，可能会有一些教学风格更好的助教，那更适合你，所以是的，我们鼓励你尝试一下，TA之间的共识，所有核心的东西是讨论是非常有帮助的，所有课程的练习和复习，尤其是考试。
所以我们鼓励你们尽可能多地参加讨论，这样你就可以得到尽可能多的，离开这个球场，每周只有一次讨论，星期一或星期二，在这一节的最后会有一个匿名调查，所以请让我们知道如何改进一个部分，好啦。
所以我经常被问到的一个问题，你是如何在六个1C中成功的，我有三个主要的技巧，你们早点开始作业，嗯，科学最好早点开始，为了更好地掌握本课将涉及的概念，因为这些概念你不仅要学会如何应用它们。
你必须从概念上理解它们，所以是的，如果你早点开始作业，你更有可能真正理解这些概念是如何工作的，我相信这学期有四五个人在上这门课，他们都是被雇来照顾你的，到办公时间来，我们是来帮你的，我们真的很想帮助你。
并伸出援手，如果你需要任何支持，任何个人冲突，请发电子邮件给六一C电子邮件，我们有很棒的，学生支持，TAS是来帮你的，所以只要伸出援手，如果你需要帮助，嗯，家庭作业1已经发布，将在本周五到期，嗯。
我现在意识到项目一可能还没有发布，但它很快就会出来，我们将做两个半星期，但要尽快开始，正如我前面提到的，到目前为止，有人对这门课有什么问题吗，有很多，哦耶，明天有个实验室，我相信还是，哦耶。
每周都会有实验室，是的嗯所以是的，最终，在那里你会有你的单圈部分和你自己的最后期限，但是嗯，尽量早点开始，在很多这样的，因为你会很惊讶，一个虫子能花你多长时间，所以说，好啦，不要紧，嗯好吧。
今天我们要学习数的表示，我们报道这个的原因是，因为第一部分是计算机用数字存储一切，不管是数字，你写代码，编写存储在计算机上的文件，所有这些都以某种方式存储在数字中，所以我们在这里要做的是弄清楚。
在我们的系统中表示信息的最佳方式是什么，所以今天我们要讨论一个基转换，从十进制到二进制或者反之亦然，十进制到十六进制，反之亦然，以此类推，以此类推，在那之后，我们将介绍几种我们实际上代表的方式。
我们系统中的数字，即符号星等，一个组成部分，两分量与偏置，和编码，关于二进制，二进制i的意思是二，所以这意味着用二进制表示的数字是以2为基数的，这意味着二进制数字中的每一位或每一位数字。
可以是两个选项之一，零还是一，一个意味着使用位的值，零表示它不是二进制数，最重要的位位于左边，最低有效位位于右边，我们会再深入一点，至于为什么会这样，一个n位二进制数最多可以表示2到n个唯一数。
因为记住每个数字可以是零也可以是一，如果你有n个数字，你可以以此类推，得到总的概率，嗯，有两个到n个唯一数，位只是一位数，一小口就是四个比特，所以字节是8位，当我们开始十六进制时，小咬将是非常重要的。
二进制的前缀是零，B有一个小数，另一方面，另一只手是基础团队，所以对于二进制，我们有十六进制的两位数字的可能性，我们有16个，这就是为什么我们喜欢称之为比二进制对眼睛更容易，因为他们有很多。
因为我们看到的许多数字，十六进制是我们以前见过的数字，例如，零到九，十进制中的数字在这里，以及一些字母表，a b，一个十六进制数字等于一个半字节，四次出价，我们将更深入地讨论这一点。
当我们开始从二进制转换为十六进制时，十六进制的前缀是零x，到目前为止我们还有什么问题吗，我们测试它的东西，像其他基地一样，提出来，鸡蛋就像其他事情一样，我相信奥亚可能在讲座中被涵盖了。
所以也许这是你可以注意的，但我个人还不太确定，所以我找到了这个PDD，所以是的，所以我们实际上正在努力发布，讨论幻灯片，对全班同学来说，现在所有部分，他们现在不在网上，但我可以我只是在聊天中分享了。
让我把它放在正在讨论的中央索引上，一会儿就上来，是啊，是啊，谢谢。还有其他问题吗，好啦，所以考虑到这一点，现在我们可以继续进行基转换，所以当我们谈论基转换时，我们有很多方法可以在数字系统之间转换。
现在我们将专注于二进制到十进制，反之亦然，所以对于二进制到十进制，关于二进制数需要注意的一点是取决于索引，其中每个数字都位于，它可以或者它可以代表一定的功率上两个，所以如果我把这个例子放大一点。
对于零b的个数，你可以看到那条曲线，是吗，大家可以看到，好啦，嗯，正如你所注意到的，呃，第一个位，LSB，右边是二的零，是索引的第0位，因此它是二的零，然后你可以把它应用到，嗯。
这种逻辑在这里的所有其他部分，所以索引1位是2比1，索引二位是二到二，以此类推，以此类推，现在我们在这种情况下可以转换为十进制的主要原因，我们知道我们可以用2的幂来表示任何正整数。
一个完美的例子是105号，是啊，是啊，我们稍后会更深入地讨论这个问题，但是是的，嗯，从二进制转换为十进制时，一旦你知道，呃，什么二的力量，呃，数字代表你所看到的，你要做的是2的幂之和。
所以你可以在这里看到，编号为1的位是2到6，二到五，二到三，二到零，因为这些值是一体的，因此，我们需要在我们的，对十进制数字的计算，所以它变成了二的六，加二到五，加二到三加二到零，六十四加三。
二加八加一，一共一百零五，然后十进制到二进制，我们用我们可以，任何正的十进制数都可以表示为2的幂，我们要做的就是找到古墓的力量，最好的方法是找到2的最大次方，它比你有的十进制数还小。
所以在五个中的一个的情况下，的，二的最大次方是六十四，然后从105减去41，然后是三二，然后你得到，如果你减去这个，你得到九个，如果你减去8，你得到1，1是2的幂，二到零，减去1得到0，你可能注意到了。
呃，因为这是正二，我们知道有一定的，呃，它们所代表的二次方指数，所以在六十四的情况下，现在是二比六，因为我们知道二到六实际上是在这个小数中使用的，在这个二进制数中，我们要做的是。
确保二进制数的第六个索引位是1，然后因为我们有2到5，我们二进制数的我们的第五个索引位是1，2的3次方也是如此，二的零次方，所以我们能够，然后在这里得到这个号码，一零一一零一，那么我们有什么问题吗。
好啦，所以现在我们可以进入二进制和十六进制，反之亦然，所以二进制到十六进制，呃这么做，从二进制数的lsb开始，你把这些碎片分成小块，一个很常见的错误，我看到很多人犯的错误，当他们吃东西的时候。
他们去了什么，他们所做的是从MSV到LSV，从左到右，这是不正确的，你得从右到左，从伦敦商学院到MSB，然后您可以使用引用表将半字节转换为十六进制，呃，我们有，我们确实鼓励尽可能多地使用这个。
所以你可以在这里看到，我们有小数点0到12，我想它有点被切断了，但是代表每个十进制数的二进制数，如果你把它转换成十六进制，你可以得到，从0到0到s，所以在这里的例子中，零b零一零一零。
结果是我们从右到左，所以第一口是1 1 0 0，根据参考图表，它是C，然后我们有零零，零一是一，然后我们有0 1 1 0也就是6，所以总的来说，我们可以得到十六进制数0 x 6。
十六进制到二进制的一个C，而不是成群结队，最终发生的是，而不是将其分组为位，我们把它扩展成碎片，一旦我们知道每个十六进制数字是多少，我们可以使用引用表将其映射到适当的二进制位。
然后创建一个完整的二进制数，从那里有谁有任何问题，我们得到了数字6，是四点一点吗，我们在左边加上是的零，是啊，是啊，这是有原因的，这实际上是主要原因，为什么我们从LSB到MSB。
因为如果你把耳朵加到右边，你有效地改变了你的数字，创造了一个比，这是一个你可能不想要的数字，那里也有细微差别，如果是有符号的数字，就像2的补数，嗯，你应该在前加1而不是0，如果是阴性。
但我们很快就会讨论的，是啊，是啊，所以它并不总是你的一件事，是啊，是啊，还有其他问题吗？好啦，所以考虑到这一点，我们现在知道从十进制到十六进制，您只需使用二进制文件作为中间人。
我们知道如何将十进制转换为二进制，约束两个的力量，一旦你找到二进制，然后你可以把它分成小块，然后找到合适的十六进制数，我相信一个很好的例子就在这张照片中，或者其实没关系，是啊，是啊，从二进制到十六进制。
但是是的，您只需使用十进制到二进制，然后二进制文本十进制，好啦，所以考虑到这一点，让我们进入工作表，呃，第二，呃，上面写着，将下列数字从其初始评级x转换为其他两个通用费率，这意味着如果它是二进制的。
转换为十进制和十六进制，如果是十六进制，转换为二进制和十进制，如果是小数，把它覆盖到二进制和x，所以我们给你们几分钟看一下，我想我们可以开始查他们中的一些人，呃，有人有什么特别的问题吗，他们想开始检查。
这里有支持吗，好啦，所以考虑到这一点，我想我能做的就是从第一个开始，所以在这里我们有一个零b，哦耶一个一个，哦对不起，是啊，是啊，呃零一零一，我们以前就知道，为了把它转换成十进制，我们要做的是。
我们得找到力量，我们必须找到两个的相关幂，与数字1的每一个位，然后我们把这些总结起来，所以在这里，这是二的零，所以这是一个，这是二比一，也就是二，然后是二三二四二对二对五，三二三六，二到八。
我相信是两个，五个，六个，所以如果你把这些加起来，二百九十一个，呃，是啊，是啊，哦耶，那件事我很抱歉，哦耶，所以这是七个，然后右边，这样七个就变成了一百二十八个，然后第四位是十六，所以让我继续。
简单地重做这个，啊，一二八，然后十六岁，然后呢，休假，是一四七，是呀，是一四七，然后为了把它转换成十六进制，会记得我们要做的是，按小口分组，所以在这种情况下，我会把它往下移一点。
所以让我们把这个变成小食，所以我们的第一个小食将位于右边，所以应该是0 0 1 1，然后我们终于有了一个零零一，然后如果我们用我们的查找表，呃，零零一一应该等于三，然后一零一等于九，所以是零九三。
或者是的，有人对此有疑问吗，有人想让我再举个例子吗，好啦，呃，我会的，呃，有人还想看这部分吗，还是我可以继续前进，我想我会继续前进，然后改变他们，接下来的b部分是将以下数字从十六进制转换为二进制。
人们有机会进入这个部分吗，是啊，是啊，所以呃，考虑到这一点，我想我只负责第一个，所以请记住，当我们将十六进制转换为二进制时，而不是像把它分组成比特，我们得把它扩展成块，所以在这种情况下我们需要做的是。
我们需要找到映射到D的适当位，在这种情况下是1-0-1，呃，是1比0 1比3，会是零，零一一，然后对于d，它又是1，0，1，所以考虑到这一点，然后我们就有了二进制数，零b一零一零一零一，哪个。
如果你们好奇的话等于五十五万四千，一百八十九，是呀，这是不寻常的，我不认为你们这学期会被骗，所以是的，把它记下来就好了，是啊，是啊，是呀，因为你面前有十六进制数字，只要确保你按正确的顺序做就行了。
这才是最重要的，还有其他问题吗？所以一个关于喜欢的问题，第一部分，我们把一个双数转换成一定是八，你为什么喜欢把它加进去是的，正如布兰登之前提到的，如果是负数，你得用一个拍打它，当我们讨论2的补数时。
我们会更深入地讨论这个问题，我知道这些问题，好极了，我想我们可以进入下一部分了，它涵盖了，我们首先要讲的是符号和星等，会签到，然后会签到，这意味着我们有一点，MSV说作为我们的标志，所以它可以是消极的。
也可以是积极的，然后我们有我们的大小，这就是所有的，右边剩下的部分，所以在这个例子中，零b一零一零，我们有，因为我们的MSB是一个，我们设定的标志是一，那就意味着它是阴性的，然后我们有z。
然后我们有剩下的我们的规模，也就是，呃，零零一零，等于2，因为它是负的，你可以把它表示为负2，然后你在底部看到的例子是，同样的号码，但被认为是积极的，因为符号位被翻转了，比率是负的，2的m-1次方。
乘以2次方再减去1，你知道这个范围是什么是非常重要的，因为你很可能会在考试中被问到这样的问题，这里的交易是有两个零，你能解释一下为什么这里的两个零，什么会，是啊，是啊，然后我们想尝试一下为什么有两个零。
我们可以，我们可以让我们的星等为零，但是我们有一个零的迹象，但我们的星座可以是正的，也可以是负的，产生正零或负零，有人对此有什么疑问吗？为什么这是一个问题，嗯，我是认真的，只是你在用。
你有可能代表另一个数字，但相反，它必须是零，有点，我就是这么想的，但在硬件上很难处理，是啊，是啊，您必须构建能够处理两个不同版本的零的组件，是啊，是啊，是在范围内减去一个来解释这一点吗。
这就是为什么我们必须减去一个，因为我们几乎浪费在零号上，完全正确，是呀，嗯是的，因为我们只有n-1位的大小，是呀，我们必须，它必须是真实的，还有其他问题吗？和数是位数，是呀，我很快就记下来。
在这些问题上，他们会明确地对你说，像你这样最重要的乐队，找到它或者，比如你问他们是否会要求你用不同的方式使用符号量，而不是之前的这个，是啊，是啊，所以如果他们做得最好，你得假设它是那种结构，是呀。
变焦上有一些人想让你再检查一遍范围，并解释为什么这些是界限，好啦，所以请记住，所以在这种情况下，并将表示位数，所以我们所拥有的，所以如果我们要表示一个一般的二进制数，我们会在这里吃一点。
然后我们有了一个M，然后我们得到n的负1位，我们可以创建的以a结尾的最大数字，位是2的n-1-1的次方，因为这基本上就像把这里的所有部分都设置为一个，然后耶，因为我们不一定能表示2到n减去1。
尤其是你需要你，如果你想表示2的n-1的次方，你需要额外的一点，因为这是一个更重要的数字，你不能用n减去1位来表示，所以这就是为什么你可以，你的绝对值最大值是2除以n减去1减去1。
然后因为我们这里还剩下一点作为标记这可以是，这意味着可以表示的数字要么是n减去1的负数，减一，或者2除以n减去1，减一，就二进制任何事物而言，这个类的基本真理是，如果你有n位。
你可以代表两个到N个不同的东西，所以是的，我们为了这个标志牺牲了一点，所以这意味着我们现在被限制在n-1，记住这一点真的很重要，这会一次又一次地出现，对事情是的，但也只有这么多，是呀。
这是你能做的最大数目，是呀，呃，还有其他问题吗？好啦，所以考虑到这一点，我们可以进入下一个表格，曾经是赞美，一定要记住，这是比较罕见的，很少用在像硬件之类的东西上，所以我会把重点放在这一点上。
但知道这一点仍然很重要，因为当我们覆盖2的补数时，我们将在这里使用非常相似的逻辑，这里发生的是m是msb是符号位，所以正整数看起来像普通的二进制表示，除了msv为零，所以在这里的情况下，在这里的情况下。
我们知道我们可以代表呃，零b零或一1等于七，所以不管我们这里有什么基本上都是正常的阳性，像整数，然而负数，我们需要做的基本上是翻转，所有的都是翻转，为了得到你的否定版本，在这种情况下。
因为我们知道7等于，为了得到负七，你得把零件翻过来，就会得到0 b 1 0 0 0，这里的范围是，我相信和嗯一样，呃，符号和星等，因为你还在保留一点，作为某种征兆，就像它不会喜欢零。
就像msv是零如果它是正的，如果它是负的，MSU将是一个，还有两个零，因为你可以代表，零为零，零零零还是一一一有人对此有什么问题吗，现在我们将进入我认为最重要的，呃，这类中表示数的表示法表示法。
也就是2的补语，在这种情况下，2的补语是选择补语，MSV是符号位，正数看起来像普通的二进制表示，MSB零的地方，所以与我们在补语中看到的非常相似，另一方面，一个人的补语和两个人的补语有什么不同。
如何从负数得到负数，你会简单地做什么，你要做的就是得到未签名的版本，所以积极的版本，但你不仅会翻转零件，你得加一个，为什么我们最后会有一个，是因为如果你，如果我们用这个例子，这里，我们知道这是七。
但这是负7，在这个例子中，我们实际上可以使用这个MSB，不仅仅是代表符号的东西，它代表着，以及设定位的大小，就像我之前说的，索引n位表示2的n次方，所以在这种情况下，因为这是索引3位，这将是两到三个。
但因为它是一个，是阴性的，然后我们可以在这里加1加2到0，所以它等于负八加一等于七，所以我们这里基本上有的，现在我们能够利用我们所有的比特和使用，更确切地说，而不是喜欢，实际上保留一点作为标志。
我们实际上能够使用所有的位并表示整个数字，所以这就是为什么这里的范围是负的，二到n减去一，以及2的n-1-1的次方，我们这里只有一个零，算术更重要，做起来很简单，如果你做一些像一次赞美。
但你必须意识到溢出，因为有可能，如果你需要额外的比特来表示更多的数字，那不一定是对的，因为假设你想做一个积极的，你有两个正数，所以你会知道它的和是正数，如果您的溢出以某种方式达到msv等于1的点。
你实际上是在创造一个负数，所以这是你必须注意的事情，任何关于选择补语的问题都是，如果你看到这个数字，你怎么知道是阴性的，但我不喜欢，哦，我想，哦耶，你知道的，所以这就是喜欢的大根源。
我想在很多这些话题上的困惑是，嗯，没有什么能告诉你这个二进制字符串之间的区别，嗯，在一个人的补语中的等价字符串之间，或者等价的字符串，就像正弦波，对呀，因为那是完全不同的数字，嗯，它实际上就像先验知识。
就像你在用什么样的约定，这就是为什么我喜欢我把这些大会，因为你作为设计师，就像我要用补码来表示我的数字系统，您还可以为不同的应用程序使用符号幅度，是否更有效率，但是是的，所以如果你在这类事情上有问题。
你会被告知它就像管子，补充和签署，或者如果你正在使用，你会发现它现在是价值的一部分，为什么范围仍然是负一，对于正数2到n减去1，从技术上讲，这仍然像正弦震级，我们可以，因为第一个比特的msv必须为零。
无论发生什么，所以你还是要用，最后的n减去1位表示最大数字，等于2的n次方减去1，但是，另一方面，如果我们想让最大的负数，我们所要做的就是让MSB成为一个，然后我们可以让剩下的位设置为零。
这回答了你的问题吗，是啊，是啊，好啦，呃，还有其他问题吗？好啦，所以呃，考虑到这一点，我们可以继续我们今天的最后一个，即偏置编码，你要用这个，加上2的补语，当我们开始组装时，所以请注意。
这也是非常重要的知道，所以假设双向编码是这样，假设你知道最小值在，或者你知道你需要表示的最小值，那就等于我们的偏见，因为我们可以做的是，如果我们把我们的数字表示为零，或者如果我们必须有一个零的二进制数。
我们可以做的是从中减去我们的偏见，这就得到了我们最大的负数，我想是什么，是啊，是啊，所以呃，等于最小值，上面说把最小值等于零，所以在这种情况下，如果我们说我们的最低值是127。
我们要做的是把最小值m设为负1 2 7，这意味着我们也把我们的偏差设置为负1 2 7，因为那会变成负1 2 7，加一二七，是零，然后为了把一个数字向负方向移动，请一定要加上负偏差，向积极的方向转变。
你加上一个积极的偏见，你有点像，你可以在这里看到，我们正在改变数字线，为了在负范围内表示A中的更多数字，所以在这个例子中，它是一个正偏差，通常在这门课上，你会看到一个消极的偏见，对于偏差，正常值。
你会看到的标准偏差是，2-2的n-1的次方，或者负2的n-1-1的次方，然后作为一个人的补充，它是n的2次方减去1减去1，所以标准偏差是这里列出的，然后这个范围与无符号范围非常相似。
也就是0和2的n减去1，但在这种情况下，取决于你决定如何移动数字线，你试图代表多少个数字，它应该同时应用于0和2到n减去1，有人有问题吗，所以我只想说，呃，你记下号码，你替你做广告，是呀，你嗯。
它是加的吗？这取决于你如何处理这个标志，所以你可以有一个消极的偏见，是啊，是啊，但如果是负面的，我们要加上负五吗，还是，是啊，是啊，我们正在添加，有什么问题吗？其他问题，是呀，为什么会在那里。
这只是你通常会看到的偏见，呃，因为我的意思是，我可以放弃的最好的例子是，每当我们使用八位，通常是负127，这就是为什么我之前说的答案是127，因为本质上我们所做的是，呃，缩放我们的整个数字线。
所以我们可以表示相等数量的负数和正数，所以这就是为什么，那是，呃，还有其他问题吗？她也缩小了一点，哦，我其实，呃，考虑到这一点，我想我们可以继续，呃，我想是你的三号，你的三号，呃，工作表右，是三号吗。
是啊，是啊，好啦，所以是的，我给你们几分钟来处理这件事，随便和你的邻居谈谈，如果你需要任何澄清，或者需要帮助就问我们，呃，呵呵，就是这样，在聊天中，这实际上是一个很好的问题，比如偏见的意义是什么。
我有点喜欢这个问题，因为我觉得我在第一行就问了同样的问题，本质上它允许你把这个无符号数范围，从0到2再到n减去1，嗯，但你可以转移它，假设你需要一个数字系统，可以代表500到7000。
你可以用无符号数字表示0到7千，但你在前500英镑上浪费了一点，说你知道你永远不会用那些数字，所以你可以用更少的比特来表示你需要的实际范围，但只要把整个数字系统移过来，如果有道理的话，是啊，是啊。
当我们开始使用浮点运算时，这种原理会更加普遍，所以是的，记住这一点，而且如果你按标准拍的话，总是会有一个正数比群体多吗，取决于您是否使用标准的，是呀，但从技术上讲，如果你认为零为负，你可以算它相等。
但是是的，否，是的，是有一个广泛的喜欢，我能做的就是，我不认为，两种可能，你怎么，你是什么意思，像一个平等的人，正负数，好像你知道，假设我永远不需要代表你，有没有办法喜欢，把它弄得像，如果我在某个数字。
我喜欢，再减去一个，所以我去掉了范围内的数字，我想你可以用，就像2的补语系统，然后还有一个偏见，所以你可以代表0到128，但也要移动一个，这样你就可以表示它们的负面版本，还有人在变焦。
你能听清楚学生的问题吗，否则我可以试着重复给你听，好啦，也是两个人的，可能总有一辆公共汽车，所有的是，是啊，是啊，因为你可以用负数表示二减一，而不是它的正面形式，就像，五分钟左右，然后就像现在，就像耶。
有几个，好啦，所以开始写下这个问题的答案，所以我只想知道，我要花一点时间来回顾一下，所以对于未签名的，我们知道我们的范围是0到2的n-1，因此我们的最大值是2的8减去1，一共是二百五十五，然后加上一个。
我们会给出一个溢出，所以虽然我们会有一个额外的一点在旁边，剩下的八位都是零，所以我们得零分，然后类似的事情有偏见，这是一种，嗯，当我们得到一二八，当我们加上一个，我们会得到另一个溢出。
如果你给它加上某种偏见，减去127，然后我们最大的二人组是一百二十七，因为它是2的n减去1减去1，如果你加上这个，你就会产生另一个溢出，所以是负数，二十八不是真的溢出来了，这只是MV，就是这样一个。
这是我想要的，偏见，好啦，所以对于偏见，嗯，我知道怎么去，所以代表一百二十八，这意味着，嗯，其实我先过去补充一下，所以为了补充，如果我们有八个比特，我们知道我们是我们最大的数字将是正的。
这意味着我们的MSB将为零，其余的位将为一，这是我们两个的补数，作为我们的，我把这个，这是我们作为两个补充的最大数字，但是，如果我们想，如果我们在这个数字上加一个，结果会是什么，最终会发生什么。
它变成了零，然后你拿着一个，然后我们一直带着一个直到我们到这里，这就给了我们这个数字，记住msb表示负2的索引位的次方，因为我们的索引位是7，这个数字是负2的7，是负一，二八，这就是2的补数，另一方面。
偏见，嗯好吧，我要去，我需要一点时间，哦耶，所以嗯，记住，偏见会改变一切，所以我们可以在无符号版本中表示的最大数字，在视觉上看起来像任何人，所有的，是的所以当你把一个加到所有的，接下来会发生什么。
你得到一个溢出位，然后你就什么都没有了，但请记住，我们将这些无符号数字映射到我们的偏差的方法是，我们只是把这个负的1，2，7加进去，所以如果我们都有，然后我们再加一负一二七，我们最后会有一二八，对呀。
因为最大的数字和8位无符号，一共是2，5，5，再减去一二七，好啦，所以如果你加上一个，那么现在你有所有的零，然后你从0中减去一二七，这给了你负面的，一二七有道理，我也可以把它画出来。
这可能是一个比任何有意义的东西都更好的视觉例子，每个人，好啦，所以我们还有一分钟，所以很不幸我们无法完成剩下的部分，但我确实想花点时间快速复习一下预先检查的问题，所以第一，所以呃，鉴于我们今天所学到的。
希望你们能够理解并回答这些问题，所以我只想问你们，取决于上下文，相同的位序列可能代表不同的东西，真假真，是呀，因为我们有不同数量的表示，在2的补码中有可能得到溢出误差，当把相反符号的数目相加时。
真的是的，因为在本案中，如果我们把1加1加2加7，我们，你会认为我们会得到一二八，取而代之的是，我们得到负一二八，这有点像，我们得到某种溢出的原因，哦其实等等，对不起，给我一分钟，甜甜的，是啊，是啊。
这是假的，呃，原谅我，嗯，哎呦，是呀，上面写着，相反数，所以是的，你永远不会，呃，如果你加上相反的符号，你可以用2的补数表示任何一个数，这样就不会溢出来，如果你，但是有两个相同符号的数字。
您很可能会得到溢出，好啦，所以如果你把一个n位2的补数解释为一个无符号数，负数会小于正数，真假，假的，是呀，好啦，嗯，然后如果你解释一个n位偏差符号数，好啦，这是个诡计问题。
我们可以用给定的表示格式表示分数和小数，未签名，有偏见，二的补语，答案既不是真的也不是假的，你会学到这个浮点，因为它是一对数字表示的组合，是啊，是啊，是啊，是啊，有点被包裹着，是啊，是啊，好啦。
在大家离开之前快点，嗯好吧，首先，这是阿基尔的第一次讨论，所以呃，谢谢你和我们在一起，嗯，它真的帮助我们学会如何更好地帮助你，所以请大家快速扫描一下，这是一个很短的形式，需要两秒钟。
别忘了下周星期一是假日，所以我们的部门，星期二有一节，然后我们现在就会回到彼此身边，还有，当我们把这些幻灯片上传到网上，你会走到最后，有一个范围表，显示，就像未签名的，偏置符号，他的赞美，无论如何。
我做得很高很高很高，建议大家记住，如果你不能使用备忘单，所以是的，好啦，因为你肯定会被问到，就像，最大的数字是多少？的最小数目是多少，哼，呃，那将在中央环节，呃和邮政，是啊，是啊，是啊，是啊。
非常感谢你能来，是啊，是啊，我们两周和两周后见，谢谢你和岁月，你熟悉家庭作业的问题吗？对不起，是呀，我认为对于缩放问题的偏见之一，这是一个积极的方面，你给我一秒钟，是啊，是啊，你可以用肯定的说法。
也可以根据情况而定，是呀，如果你想改变你的，如果你想转移你的数字线，更像是积极的而不是积极的，反胃阴性，所以如果我没记错的话，就像一个非常像，这是一个现实生活中的例子，但后来它给出了确切的事情是。
你得记住，你可以很好地添加或减去符号，那你就是不愿意--你能重复一遍你的问题吗？我不记得真实的生活情况了，但它说的就像，你要么用负一二十七要么用正一二十七，所以正一点七，如果你是。
如果你想忽略所有的数字，在零到一二六之间，对呀，然后你用像，你得到一个，它说你应该像你一样使用两者，我有个问题，你一秒钟前，让我们说，记住这个问题，我对这个问题不太熟悉，所以我亲自，我帮不上忙，好啦。
谢谢你，所以说，不客气，我有一个关于第七张幻灯片的问题，哎呦，等一下，呃，你不在这里，对不对，你们都七十多岁了，虽然，他们在幻灯片上说两个互补和一个互补的偏见，符号和星等，所以我给出了三个系统的偏差。
这对我来说毫无意义，因为我问了这个关于偏见的问题，他们说偏见不用于。
嗯，其他系统，除了偏右的那个，现在是匿名的，给你们的变焦，我想我有几个问题在这里，我可以鼓励你们在，呃，发布此讨论，我马上去看看，我有，离开这个房间，关闭变焦呼叫，是啊，是啊。
P40：Lecture 30： Parallelism II： OpenMP,Sharing lssues - 这样好__ - BV1s7421T7XR
我只是在猜想。
視覺上的遊戲玩家，是否能夠看到螢幕，如果你是視覺上的玩家，大部分遊戲都不能夠看到螢幕，這真的很可惜，所以我所說的，這是第一個，只有音量的電腦遊戲，這很難相信，我這麼說是因為，我玩過一些電動遊戲，在車上。
你可以玩電動遊戲，你在聊天的時候，我手上沒有開啟手機，但我在聊天的時候，有一點像是逃跑，你可以在Alexa上做一個逃跑房，這真的蠻好玩的，你可以去探索一下，免費的，你可以買一些額外的等級，所以我做的。
這算是一個遊戲吧，我走的步驟，我拿著繩子，然後把它們綁在車上，這是一些有趣的東西，但這不是一個遊戲遊戲，在手機遊戲的意義上，像是Twitch的反應遊戲，所以這在理論上，是，我寫在這裡，遊戲是一個。
在英國的慈善團體，Cost Charities，獲得了，Optical Retail Chain，Specsavers Inspire Award，由一隊，蘭卡斯特大學研究生團隊，創建了，世界第一。
只有音量的，電腦遊戲，我說的，也許是比較像Twitch的，反應的東西，但是，遊戲是，透過16層的洞穴，探索視覺障礙者，使用單純的聲音，來運行，遊戲是，沒有任何螢幕或聲音，當然，我玩的遊戲，是有聲音的。
你會聽到，是一個轉動的東西，這很酷，我想鼓勵更多的研究生，支持，視覺障礙者，和更多這樣的遊戲，所以很棒，慶祝，我看到的，是第一次，只有聲音，Twitch的，反應遊戲，讓我們來看看更多，我覺得這很愉快。
好東西，我想要強調，這件事，各位先生女士，歡迎來到，61C，Thread Level Parallelism Part 2，很高興見到你們。
如常，好，我們來開始聊聊。
Parallel Programming，語言，這些語言，支援，Parallel Programming，不同的層次，這可能是，控制很多機器，這可能是，控制機器的核心，不同層次的Parallelism。
看看這個，我在數嗎，是40，大約，40多，Parallel Programming，語言，看看你們的最愛語言，在這張清單上，很有趣，所以，我問你們，你們選哪個，好，我們開始，我們來看看表現。
你們有Project 4，Project 4是關於表現的，當然你們都知道C，我們想教你們，和一些圖書館一起教你們C，但是，我們來說說，只是玩玩，Lisa和我決定，開放任何語言，瘋狂地，任何語言你們想。
你們怎麼選，這很難，你們選擇了很多東西。
為什麼有這麼多，首先，我們要問，為什麼有陶瓷，陶瓷是一個方法，能夠明確地告訴你的組織，這是我想要你做的，這是我希望CMD的範圍，能夠有多廣，對，這是很棒的，CMD的功能很棒，記住。
CMD就是一個很廣的範圍，當你做這些，任何任何的工作，當然這是一項，非常激烈的研究，而，各位，研究進步，20年，去想要，怎麼翻譯，只用簡約C，簡約C，你不用做任何明確的工作，你不用做陶瓷，你只要說。
我想做一些東西，C是一個很快的語言，最後，C是一個錯誤的語言，C是關於，如何明確地翻譯，如何把這個部分，轉到這裡，你差不多想要，一個更高級的語言，像是SCHEME或PYTHON，說我想做這個。
複雜的複製碼碼，然後你來決定，怎麼做，所以C是一個，差在哪裡，差在哪裡，開始，因為它是，我知道，這個機器的運作，和現金的運作，和部分的運作，我想把這個部分，轉到這裡，然後做這個，你真的想要一個。
大型高級複製碼碼，讓我，在組件中，去更好地轉譯，所以，要翻譯C，或是像我說的，其他語言，到非常非常快的，對比式文字，這條問題，真的是太難了，他們已經在工作，20年了，很多很多的PhD的學生，都在找人。
在找一個新的語言，或者是一個，可以支援程式的人，如果你只用我們的方式，就更加有效地，翻譯成功，自動翻譯，intel其實也試過，他們有，我忘了這個東西的名字，他們有一個新的，如果你想要，更好地轉譯。
GPU，我之前也有說過，GPU有一個講座，我們正在討論，Apple，為他們的工程師，帶來一些東西，非常興奮，有一個GPU講座，給他們一個讚，GPU是一個，其他源頭，如果你可以，擁有一個，普通的GPU。
你只要寫一個程式，就能夠，你告訴它，你擁有的東西，我擁有這個GPU，或許我擁有，一個外置GPU，或許兩個，你可能有，其他網路的電腦，我會說，這是我擁有的，電腦程式，你去做最快的，最快的轉譯，你就能做到。
這是一個很好的方法。
總之，沒有一個明確的答案，他們有一個解決方案，我們來看看，社會如何回應，好，所以，選擇的數量，是一個表明，沒有一個宇宙性的解決方案，不是說，我們都同意，順便說，大部分人都同意，Python是一種方式。
教授初級數位數學，是最容易的語言，當然，空間有一個，相似的意義，這是有點奇怪，但是大部分人都意識到，Python是比其他東西，我們都用得更好，C++，和Java，還有其他語言，還有C，我的天啊。
人們都在用C。
幾年前，我們在南部的學校，也有在用C，作為他們的初級語言，啊，瘋的，我們從來沒有這樣做，所以，這是一個指標，但是還有一個指標，就是，他們有不同的任務，你會有科學數據，可能會在很多，流動點上，做一些工作。
他們在關心，這個多數的數字，網路伺服器，可能在處理，一些不同的問題，但是在另一個層面，我處理了一百萬的要求，因為我是CNN，我需要處理，每一個人，在找一些，新的地區新聞，在發生。
輸入輸出，說明，事情都在同時發生，所以這是另一個方式，我們沒有說過。
I/O，是關於數據的，你也知道，發生了什麼事，我們沒有說過，I/O的要求，在他們到來的時候，是不在你的控制之中，我們最接近，說到I/O的時候，就是在你，的集數機，記得嗎，第一天的SDS。
我們有一個集數機，你無法控制，X的進入，你記得那是一個X，你會有X0，加上X1，加上X2，你無法控制，X的進入，所以這是我們第一次，說到I，至少是一個問題，是一個無法同時發生的問題，特別的語言。
是用不同的工作，在621C，我們嘗試要強調C，我們嘗試要利用，我們到目前為止，所教你的，就是C語言，我們今天要教你，叫做OpenMP，這是一個圖書館的結構。
讓你得到，這些核心的資訊，來控制它，所以我們馬上開始，OpenMP，在這堂課之後，順便提醒，請把你的電腦打開，來跟著我來碼頭，如果你想要嘗試，好，Parallel loops，這是一個系統執行。
我們喜歡，只要在一顆子中，鋪一條線，0到99，看到那100個元素的，一顆子，這是一個系統執行，那在Parallel裡，發生什麼事，現在我有四個核心，我會做什麼，你想讓每個核心，隨機地，抓一些數字。
然後嘗試，做你身體裡，做的事，不，這樣就有道理，把它們分成小塊，像這裡，左邊的，如果你不能，看著文字，它說，i=0，-25，25<50，50<75，75<100，每個核心，抓一半，那些數字。
然後在那裡做事，這是一個，非常普遍的，標準，如果有，一些圖書館的支援，會非常好，對於這個非常普遍的東西，我想做一些東西，像一個地圖，我想把每個數字，切成一塊，或是一些東西。
這就是你做的，會非常好，如果有一些語言支援，對於這個，所以OpenMP，就像其他嘗試，做Parallel，像MPI，和其他東西，OpenMP說，我們來看看，能不能把，最少的一條文字改變。
所以你有你的文字，他們可以付錢，這是一種，手法，我能不能，把最少的一條文字改變，然後，他們只會說，這是一個叫做Pragma的東西，而Pragma，是被所有人都忽略了，除了有系統，有圖書館的設置。
還有多核心的設置，所以只有當你，包括OpenMP，它會看那條文字，就像隱藏的文字，只會使用，當你使用OpenMP，所以我包括了圖書館，OpenMP。h，所以我有一些，有關於一些方式的，我說方式。
不是說Java，一些功能，OpenMP提供的，我只需要做這個，然後自動就能做到，這太神奇了吧，一條文字，一條文字改變。
整個東西就能用了，我們來看看這個，這是一個例子，我會在現場，給你們做一個實際的示範，我們來看看，它在做什麼，我們來看看，我可能還要，放大一下，幸好Mac，讓我放大得比較容易，因為文字的寬度很小，好。
我們開始吧，我們開始，包括了StandardIO。h，包括了OpenMP。h，我把文字的數字，明確地設定為4，好，我有一條 Array，數字是0-9，n，是Array的大小，分別是int的大小，好。
然後我有一條線，PragmaOmpParallel4，我們來做一個結合吧，好，如果i是0-n，我會列出，文字的數字，i的價值，那條線，這是一個軟件的線，記得軟件的線，是如何被圖示到硬件的，誰知道。
但這是OS的一部分，在做這件事，所以，這是一個線的數字，我所列出的線的數字，是0-1-2-3，所以這樣比較好，這是它在運作的i的價值，好，那是，幸好i的價值，和a的價值是一樣的。
所以a(i)是和i(i)一樣的，0-9，0-10，然後我會做，我會，我會改變a(i)，我會改變a(i)的價值，是這裡的價值，變成以前的價值，加上，基本上我會將線的數字，塞進10的位置，你可以看到，它說。
把1的位置，0-9，保持一樣，然後再加10的位置，給線的數字，所以無論是什麼線的數字，你都會看到它在結果的系列裡，然後我會列出系列，列出系列，然後我會運作，然後會發生什麼事，這就是會發生的事。
我顏色上了這個，順便說，這是你運作的方式，這個顏色是在我們的檔案裡，你可以去看看這個檔案，我們會把連結放在網頁，我還會再次運作，但是我想給大家看這個，1的位置是數字，0-1-2-3-4-9。
10的位置是連結的數字，我顏色上了它們，所以橘色的都是連結0，這就變成0-1-2，因為如果是一個系列，你會想要1的核心，是0-1-2，2的核心是下一個區域，下一個顏色是藍色，這就變成3-4-5。
這很合理，你把它分成兩半，你得到1的系列。
你得到2的系列，這很合理，你得到3的系列，你得到4的系列，你想要它們都合理，為了現金的原因，所以綠色得到，因為這顯然不是多數的4，綠色得到2個，紫色得到2個，但是看一下這個系列，0-1-2-3。
0-1-2-3-0-1，所以它們是一種系列，但是現在，這只是一個，這只是一個運作，注意到，0的系列總是得到1-2，1的核心得到3-4-5，2的核心得到6-7。
3的核心得到8-9，現在我們來運作，看這多酷，我們現在直播運作，啪，線的系列的命令是什麼，3-2-1-0，有趣嗎，我們再運作一次，3-0-2-1，那這個系列的命令是否重要呢，不重要，因為它們都只是。
在這個系列的一部分上運作，但是你必須寫一份，可以任何一個系列運作的文件，這就是Ed Lee說的那部分，我有一張圖片，是關於管理這個不決心，這就是為什麼這麼難，這就是為什麼線階，啊哦，我們要走了嗎。
我們要走了嗎，這是手機，這是手機應用程式，我以為那是發射聲，謝謝，OK，不要慌張，我們還好，那是一個，Amber Alerts，在手機上，我們還好，但是確認你的手機，看看有沒有。
Silver Prius或其他東西，做錯了什麼，OK，我們開始，我們再一次，0-3-1，哦，看這，0-3-1，然後還有1-0要運作，這不酷嗎，這真是酷，看到這個行程，就把他們放在那裡，誰先完成，你就是。
你就是在線上，來吧，我們開始，我們開始，他們的命令，你必須寫一份，不可靠的命令。
這對你來說是新的，這對你來說是非常難的，這對你來說是新的，為什麼寫一份不可靠的命令，是非常難的，有什麼問題嗎，這是4。c，有什麼問題嗎，叫什麼名字，Leo，Leo，去吧，如果你有一個核心，我理解為什麼。
你需要多一條線，因為你需要多一個核心，沒錯，如果你有一個核心，你能在一個核心上運作嗎，我們學到了什麼，我們能在，老的Pentium 4建築上運作嗎，是的，你可以在一個核心上，運作不可靠的命令。
這比在那個核心上更快嗎，不，因為有時間，把線換掉，所以你其實，能在一個核心上運作得更快，比你自己把線插進去，如果我們有更多的核心。
我們會更快，這是目標，Selania，(…)。
OpenMP做了一個管理，把線插進去，你得說，你需要多少核心，你需要多少線，我已經說過了，有一個方法，可以要求最多的核心，我認為它說，看，OpenMP 得到最多的核心，你可以說。
OpenMP 設定的核心數量，是OpenMP 得到最多的核心，然後你最多的核心，好嗎，好，我們繼續，好。
所以OpenMP 總體上是什麼，它是一個C-Extension，沒有新語言，一條線，事實上，它幾乎是為了，你存在的對比文件，最少的改變，來做最佳的調整，你只需要在對比文件中，加一個for-loop。
你只需要在對比文件中加一個for-loop，你只需要在對比文件中加一條線，你只需要在對比文件中加一條線，你只需要在對比文件中加一條線，或者像這樣，它是多條線的，共用記憶體，我們說的共用記憶體模式。
這些系統都假設，這些線子，都有同一個記憶體空間，的擁有，組成方案是pragma，如果它不被用，就不存在了，記憶體的軟件，是include_omp。h，就像我剛才說的，無法在OpenMP上。
不存在於組成方案，同樣的源頭，有多個建築，這意味著，同樣的程式，有多個建築，這意味著，同樣的程式，有1個或16個核心，我猜我們看到，一個Intel的27個核心，或者28個核心，我相信，它只用共用記憶體。
所以這是主意，我們假設。
所有的核心，共用記憶體，這就用了，叫做fork-and-join的模式，這就是一個模式，叫做software pattern，你正在用很多，這其實是一個很大的動作，這其實是一個很大的動作，幾年前的。
pattern movement，它就像，你看，你用了很多軟件，你用了很多軟件，你用了很多軟件，好多人都在不同的应用上做同一件事，这些是在纳入和减少的，这是一个图案，这个扎在一起的是一个相对机计的图案。
就是说，你开始用这个产品选项，这个主机线，然后一直扎在一起，然后一直在线上，后来，只有并行然后尽希望在最好的情况下在同一时间完成，但是在最坏的情况下，其中一个完成在如此一段时间前，另一个就停止了。
没关系，然后它们合起来，我完成了，这些都完成了，这些都完成了，四组的结尾都完成了，现在我回到原来的设计图上，所以，主机线，所有的单线都是原来的设计图上的细节，所有的平行线都是原来的设计图上的细节，所以。
你可能会在设计图上再次扎一根，再做一个四组，分开，工作平行，然后再重新组合，我们还没有看到一句叫做"阿姆多斯法"的词，我们将在课36中看到，我们在课29中，我认为，所以，这将是七个课，我们将在此时讲。
但是，我将给你一个简单的提示，就是"阿姆多斯法"是说，只要你能够继续继续继续，每次你工作平行，你都不是能够做得那么顺利，当然，所有的细节，所有的核心都准备好，准备好撤离，但是，每次你工作平行。
只有一个它们能够在同一时间内运行，所以，你只要做到最多的平行，所以，在遇到平行细节时，它会进入一组平行细节，连续连续运行，最后，有一个"加"字说道这些，我还提到"阿姆多斯法"。
好的，所以我们有什么样的细节，我之前提到过，它们是软件细节，软件细节是当系统拿出一个软件细节，然后给它进行实际的核心运作，然后它就变成了一个软件细节，所以，你正在创造一个软件细节，它们在互联网上。
它们在互联网上，不是互联网，但是它们在这里，在空中飘落，然后它们只要被抓住，并被软件细节设置成为核心，OS会将要求的软件连续连续运行到可用的软件细节，希望它们都能连续连续运行。
所以OS的时间不会连续连续连续连续，这意味着，连续连续连续连续是一种时间分享，我说，你知道吗，我只有一台机器，一个核心，就像我之前提到的，如果我只有一台机器，一个核心，我能怎么运行，我还可以运行。
但是有些时间，有些时间，然后我会把它们分开，这很烦，也不太有效率，你只想它们完全连续连续运行，然后你完成了就完成了，所以你不需要为它们调节时间，好，但是这就是主意，其他设备，比如说机器。
它们在竞争硬件线，你在运行一台机器，它有一定数量的硬件线，有一定数量的核心，有一定数量的硬件线，它能运行，你还在运行其他东西，所以如果你要调节平行的速度，你应该调节到凌晨五点，调节到没有人在场。
确保你的机器基本上是静止的，如果你想要一台电脑，想要调节程序，就把其他东西都放弃，放弃Dropbox，放弃Google Drive在背后的沉浸，所有现在在消耗你的CPU的东西，全部放弃。
然后运行你的时机，运行你的平行计算机，看看它能做得怎么样，因为现实是，它是一个共享的资源，那些核心是一个共享的资源，它们在调节你的屏幕，你运行得快，你运行得快，你下载了一个文件在背后。
这些东西都在消耗至少一个核心，你希望那些核心能够，所有的核心能够做到你能做的最好，当你做你的测试。
做你的时机，看你能运行的速度，好了，我们来进一步，我们来实际的测试，我们想要做一件叫做，恶意的平行计算，恶意的平行问题，这些问题是如此的危险，他们不需要担心他们的邻居，每一件事都会是一个独立的。
这是完美的，就像那个数据，每一个人只是把它们拿走，然后加上一个十字数，在这里，我想能够计算π，这更好，因为我甚至不需要去记忆，甚至没有一个共享的资源，去记忆。
去看一个数据来做一些事，我只是要计算一些东西，然后计算π，所以我们开始吧，好了，那么这是一个圆圈的数据，一个阶段，一个阶段，一个阶段的范围是πr²。
让我们来做r1，r是1，中间的圆圈是什么。
那圆圈的数据是什么，x²+y²=1²，记得吗，有点不清楚，可能，好的，解决于y，所以你可以有一些阶段，所以解决于y，把y放在一边，所以x²+y²=1²，把x放在那里，就变成y²=1，1²=1，1-x²。
把两边的sqrt(r)，你会得到y=sqrt(1-x²)，看到了吗，现在，πr²，但是如果我说这个范围，这是整个圆圈的范围，但是如果我只是说，0-1的范围，我会看这个正面，那是1/4，1/4π。
我不想要π/4，我想要π，那就是把4的数字多了，所以4xsqrt(1-x²)，应该是π，所以我来解决，在数学上，我写了，把4xsqrt(1-x²)，从0到1，π，结果是π，第一个字，呼，问题是。
sqrt(1-x²)很烦，sqrt(1-x²)不是很快，sqrt(1-x²)可能要多一点，可能要多一点，我们不喜欢sqrt(1-x²)，还有一个方法，对于π的范围，就是4/(1+x²)。
这比sqrt(1-x²)更好，所以我们用这个方法，这是主意，在数学上，我们知道，4/(1+x²)dx，从0到1是π，你们可以花点时间，在数学上解决，现在，谁知道如何，把一个数字做成一个组合，某个数学家。
叫做伯纳尔，大家认识他吗，R，Riemann，伯纳尔·Riemann，他想到一个方法，让你们可以有一个小小的箱子，小小的图案，如果你们把图案做得小小的，它就会接近，这个绕过弯的结果，明白吗。
所以让我们做一下，让我们把π的图案加进去，来得到π，让我们试试，这是整个计算，我们可以加上图案，4/(1+x²)。
从0到1，让我们试试，让我们一起试试，嘟，这是一些文字，我会放大，让你们可以看，因为我知道，这很难，这是一个小字，让我们一起玩，开始，嘟，这些是π的数字，如果你们在意，这是一个不合理的数字。
所以这是一个无数的数字，3。1415926535，26535，这些数字会在我记录下，897 932 384 626 433等等，好，那么这个文字会做什么，数字的步骤，我们有10个步骤。
我们要做10个不同的角形，步骤是1/数字的步骤，这是步骤的大小，我们要按照这个数字步骤，数字是0，我们要，这应该是π，我们说数字是0，是什么，现在这是重要的事情，很多人，当他们笨笨地写这些东西时。
他们并没有意识到，你的四个步骤，应该是一个数字的数值，你不应该是一个四个步骤，在你在运行过程中，在你在运行过程中，的数字是一个浮在水面的数值，你们知道为什么吗，最好的练习，因为，在你浮在水面的数值下。
有时你可能会，有一个顶级的数值，在线条的情况下，你不想，当我改变了五到二十步骤，现在我有十，现在我有十一，现在我有二十一，现在我有四十，现在我有八十一，你不想要，你想要有一个明确的数值，你有多少步骤。
所以我会在，我的四个步骤，会在数字的数字上，但是我会用一些，浮在水面的数值，比如数字和步骤，在我的计算中，所以只有在你的最好的练习，当你在做数学计算，在科学计算中，让你的四个步骤，在数字上。
而不是在浮在水面的数值上，这是最好的练习，这是我自己的礼物，好，所以我会有，数量的步骤，乘以数量的步骤，和数量的箱子，它的价值是，它的价值是什么，x=i+1/2，乘以步骤，所以我会知道，我现在在哪里。
我现在在哪里，我现在在哪里，我现在在哪里，我现在在哪里，我现在在哪里，我现在在哪里，我现在在哪里，我现在在哪里，我现在在哪里，我现在在哪里，然后数字是，四乘以步骤，加上这个，这是4x，如果你想一下。
这是x，4加上，步骤大小，1/x^2，步骤大小，这个+是区域，这个+是区域，所以x是，我把这个数字放在x，步骤大小是，是我这个，这个步骤的大小，所以这个可以，让我们试试，我运行这个，我得到3。
142425985，不完美，但我只有10步，但还不错，还不错。
3。141，这是3。142，我可以运行这个。
我做了一个小的计划，每个数字的数据，是这个，我们做一个运行，我写了Pi，是Pi的实际价值，我写了，我写了这个价值，我印出这个，我说印出这个，在这个数据上，所以每次我们看到Pi的上半数，它就近得很。
注意到它在千数的位置上。
有点远，不错，好，所以这是Pi的运行，但是我们说的是，如何使用OpenMP，现在我们用一个简单的方法，来对比，嘣，Pi不太准确，只有10步。
让我们增加步数，并对比，嘣，好，我们还没有增加步数，还在10步，我只需要，说的是，Pragma Parallel 4，这就是我必须做的，好，Parallel 4，不错，你看到这个数字。
+=4*stepSize，但是有个问题，每一条线，注意一下，数字，开始在4轮外，你看到4轮的Parallel部分，数字在4轮外，但是我在4轮内增加，然后这个文件说，你知道吗，这会出现麻烦。
我们不能有多条线，全部都可以输入这个数字，这会给你麻烦，所以这个其实可以，给你同样的价值，可以看到。
它叫做Parallel Parallelized 1，这是Parallelized 1，让我们一起认识，这是一个过渡，让我们来做Parallelized 1，Parallelized 1。
同样的价值，对吧，看，同样的价值，但是，它没有更快，它没有更快，它并没有，它变成了一条软件线，因为它看到，数字在你的轮子里，数字开始在4轮外，它说我不能分开，这不可能，所以，这是问题，那我们怎么解决。
文件是会运行连接的。
所以我们来想一下，我们怎么想这个数字，每一个人都会，从各个地方，找出所有的数字，各个小角，但问题是，我怎么解决这个数字，他们都需要计算一个数字，如果每一个软件线，都能够记住，自己的数字，当当当。
这是关键的事情，这是目前的关键知识，目前我给你们展示的，图书馆，这是你第一个学习的事情，就是你需要每一个线，都记住自己的数字，好，现在你很酷，现在每一个人都能够，记住自己的数字，然后你需要想一下。
我怎么在最后，把所有的数字加在一起，好，所以数字数0和数1，在同一方向，这是两个软件线，然后数字，整体数，是这些小块的数字，0和1等等，在连接上，这是加在一起的，一般来说这是加在一起的，你加在一起。
它们都完成了，但是你，从虚拟的角度来看，你还是在加在一起，所有的数字，虽然虚拟的角度已经停止了，但是你还是要在，加在一起的方式里，让所有的数字都加在一起。
就这样，所以我们开始吧，我只需要做的，这里有什么不同，我只需要做的，现在我有，数字，而不是单单的数字，是一个软件，我会有多少个线，我会开始在四个线上，之后我会做很多个线，这会很酷，这是软件线。
我做了数字，这一个线，我总是说，你总是要用，四个线的准备格，在很少的情况下，最好是，如果你有一个四个线，有一个正确的指示，把它们放在同一个线上，现在这很明显，对所有，我的准备格，我把准备格给你。
这很明显，这基本上是一个，非常简单的方法，把所有的数字都降到0，这是一个非常清晰的方法，这是一个接受的训练，能够没有准备格，但在同一个线上，跟着四个线，我把数字的准备格，放在这里，而不是把四个准备格。
放在这里，我把它放在这里，我可以把它，放在上面，这是四个，其他的都是一样的，现在这个，这个变成了数字的ID，因为ID就是，收到的准备格数，这很漂亮，是0，1，2，3，我们说了四个准备格，它们的数字是0。
2，但准备格数少于0，所以是0，1，2，3，现在就完美了，所以这里有一个数字，它有一个空间，0，1，2，3，我把它们全部放到0，我告诉OMP系统，把它们放到4个准备格，就是4，然后每一个数字。
都得到这个准备格，这个准备格的贡献，好，现在我完成了，我说2π是0，然后这里是同样的，四个准备格，同样的一条四个准备格，但我只是加上所有的数字，而通常，这不会那么难，我意思是，这是很多的数学。
这是很多人，在这里做很多工作，这可能会很大，这只是我有多少条线，可能是1000，好，所以我必须付1000的费用，4个准备格，没关系，真的没关系，好，好，按照步数来看，可能会很大，步数可能会是1万。
所以我只是在测量很小的，但我只是在超过，1000条不同的线，没关系，我们来运行这个，你会看到，对了，这是很酷的，它显示了，我们现在还在印，对了，我们在印，i的数值和ID的数值，注意。
我还在看到一样的事情，就是，看这个ID，ID是，ID的数字是，线ID，i是这个运行的数值，所以，我们来看看，我们来看看，i是0，ID是0，i是1，然后线ID是，步数，i是ID，好，所以这个其实很酷。
一份文件，我想确保你能够理解，这让我感到很混乱，我第一次看到这个，我先确定一下，这很清楚，这很有趣，你开始，i是ID，然后i加=，无线，所以我们来一起做，所以这里是，我会在这个空间里测量，这是π。
我会在这个空间里测量0到1，我开始，我会在这里测量，i，开始，开始，i的数值，线ID的数值，你看，我看到了一个线数，所以，我们说它有四个线，这意味着，0是线数，ID的数字，0，那么它会在这里运行什么。
i+=num_thread，所以这意味着，我们来这里，ID的数字，所以这意味着，核0会做0。
接下来的会是+=num_thread，它会是0。
4，8，之前我说过，核一开始应该切成两半，它应该拥有整个图案，然后下一步核应该拥有这部分图案，和这部分图案，但是没有关系，我说一下，没有Pi的问题，它不需要核的图案，再有一个细分的区域。
我只是在参考这个空间，以某种方式，这些都很尴尬地相反，所以这很酷，说i=0=ID，所以，0 4 8 16等等，这些都会在同一颜色，注意到这里，i=0是红色，4=ID0，8=ID0，看到了吗，所以不说。
这整个区域是一台机器，一个核，这整个区域是另一个机器，它会说，不不不，我分开空间，用数据来分配，所以这些都是黄色的，这里是一个核，看到了吗，0 4 8，同样的ID，接下来的一颗，这颗是另一个颜色。
它会说，我要拿一颗，因为我开始，ID=数据的数据，所以这意味着现在看绿色，看绿色，绿色得到1 5 9，看到了吗，所以下一个机器得到5 9，这很有趣，17等等，这就是会发生的，这证明，如果我做到4。
我会有多少个ID，我有4个，我说过，数据是4，但是每个线都会拿，从它的数据开始，数据开始，以确保没有两个线，在加4，我们都在加4，不，我们不这样做，因为4的路径，这很聪明，所以，橘色的现在是2。
得到2 6 10等等，最后一个是，3，是鲜蓝色的，得到3 7等等，不酷吗，好的，所以，开始，这是一个对比测试，我得到3 4 1 4 2 4 2。
这还不错，但我只有10个步骤，所以现在我们开始，num步骤=10^6，这个scale up，我只需要改成num步骤，从10到1万，我明显地隐藏了列表，否则我会有1万个列表。
这就是我做的，开始，scale up。
我好兴奋，parallel，我认为它叫pi scale up，开始，而且，Pi是答案，好的，女士们先生们，耶，这不酷吗，你想看，调源的文件，到parallel，pi scale up。c。
你看，我刚才给你们展示的文件，是我做的所有工作，然后我打印f pi，是一个低调的pi，然后是一个上调的pi，是这个巨大的50个pi，看我能够多近，它打印的文件，我能够打印的近，证明。
它显然没有打印所有的数字，它没有能力，用双方来存储。
但是，我说过，当你运行时，基本上它们是相同的，只要双方能够存储，这太棒了，你可能会问，我们需要用1万个数字吗，我可以用，我可以用1万个数字，来达到这一场比赛，只有100万，你可以用这些数字来达到。
可能1万个数字是太多的，可能100万或1万个数字是太多的。
你可以用这些数字来达到，这不酷吗，好，让我暂停一下，让我问问问题，是的，这不太好玩吗，我只是想庆祝一下，这真的是一个很好玩的方式，我还有一个问题，我还有更多的问题要问，但没关系。
我可以用20分钟来回答这个问题，但我需要点时间，你再说一次，我可以说一次吗。
好的 开始，(问：如果你有8个硬件的硬件)，是的。
(问：如果你有8个硬件的硬件)，8个硬件的硬件，(问：如果你有8个硬件的硬件)，是的，(问：你最好的数字是如何设置的)，啊，这就是我这一部分的最好的问题，如果你知道你有8个不同的核心。
你最好的数字是如何设置的，你设置到8个，你有一个OS，OS需要运作，也许7个更好，就想着OS可以运作一个，我可以有7个自己的，所以你把整个世界分成7个不同的东西，但也许是你特别的，这只是一个运算。
但也许你有一个特殊的情况，一个核心的一个任务比另一个更难，因为某种方式，如果你分成7个同样的部分，6个都很开心，但是最后7个确实需要你通过，所以你只是在等待最慢的轮子，你见过一只小狗在前面走路。
然后有一个很慢的小狗，他就说：快点，我们要走，狗狗来了，所以你在等待最慢的轮子，所以可能有道理把问题分成更小的部分，让更慢的核心，无论是什么原因，可能是记忆的方式，可能是所有的现金都被减少了。
现金在那个区域里冷，谁知道是什么原因，这就是我喜欢让你来玩，让你来玩，并改变那些线条的数量，从我所有的数量，在核心上，甚至是邮轮的数量，现在是两个数量的数量，物理的数量，我们在上一堂课中谈到的。
到更大的数量，看看是什么，看看是否把所有的东西分成，分成多余的部分，如何把你所有的线条，分成多余的部分，就在想这个问题，所以我们要玩这个，这就是我希望你来玩，看看它会怎么样，看看你的表现会有什么变化。
这很有趣，然后去计算，甚至可以从4到8到16，现在你变得更大了，看看你的表现是什么，再次说，现在是5点，没有其他东西在跑，看看它会怎么样，这其实是一个很好的谈话，非常棒的问题，我看到另一个手。
这真的很棒，对，告诉我，你再说一次，好的，请继续，我会问你，我们说的，怎么分析所有的线条，那就是分析，分析的词吗，是的，你会说明，如何去到下一个线条，这是OPENMP，非常漂亮的地方，它会帮你。
这是线条的美丽之处，你只需要说，把前方的线条困扰了，它就会帮你，这正是你想要的，那如果，你说，我们想用最高的线条，然后，把最低的线条，如果我们不说，我们想用最低的线条，然后把最低的线条，把最低的线条。
把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条。
把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条。
把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条。
把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条。
把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条。
把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条。
把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条。
把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条。
把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条。
把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条。
把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条。
把最低的线条，把最低的线条，把最低的线条，把最低的线条。
把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条。
把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，把最低的线条，等一下，怎么了？什么？但是。但是你。但是我们。为什么。为什么这么不决定呢？怎么可能呢？
我们没有证明不决定？为什么？因为有人在评论部门，"看起来这条路还不错"，"这条路的速度不大，只有1000个线"，但是。但是。但是Pi。变化了！在跑的过程中！
11，09，11。
这太疯狂了！这是怎么回事？大家看到了吗？这真的不好，这真的不好，之前Pi不正确，因为我们有步骤，这不错，但是我们只能改变数字，这太糟糕了，这就像是停火车一样，大家快点下火车，你做的什么都做错了。
我们只是想要更好，来吧，为什么。对，好，这就对了，我们在同一条线上，两条线，看起来像是在同一条Pi上，这是怎么回事？
让我们问个问题，先来这个，让我们简单化一下，但是。我喜欢你现在的想法，但是我不会给你答案，因为我想让你按下按钮，这就好玩了，来吧，记忆中的可能数值是什么？X1的位置，在这两条线上，通过两个同时的。
两条线，来吧，两条线，这怎么回事？首先，我让你知道，记忆中的数值，这是一个点，X1是一个点，*X1是100，好，所以是100，开始在100，一条线，会把数值转移到记忆中，X2，转移到记忆中的X2。
然后把它转回来，所以我希望，我希望这个，在线上做两次，做一次，从100到101，做两次，从101到102，这是我想要的，我不是说这是会发生的，这是我想要的，如果这个在线上运行，那是会发生的，好。
运行一次，100变成101，运行一次，101变成102，现在我说两台机器，要在同一时间运行，理论上，我希望是102，这是我想要的，让我们看看，为什么会发生什么，开始，投票，发邮件到22333。
或者到pollevy。com/ddg，然后投票，选择A-H，有时候是100，有时候是101，有时候是102，总是102吗，总是101吗，总是100吗，是哪个类型的，好，我看到大部分的人投票是F。
答案是F，请问为什么不是100，100是错的，为什么是100，你再说一次，对不起，(问题)，看你按照什么位置做这三个东西，你把这三个东西放在一起，有时候有人会拿到100或101，然后写这些东西。
所以有人会加1，为什么，我明白，有人可以告诉我为什么是别人，为什么是102，我希望是102，给我一个预订，我现在在做什么，传送，加载和购买，给我一个预订，这是传送，加载和购买，为核心1，线1，传送。
加载和购买，为线2，给我一个预订，给你102，有人告诉我，我怎么把手指放在这里，给我102，有人没有把手伸出来，我放在后面，后面通常很安静，给我一点爱，在后面，有人，这三个东西的订单是什么，记住了。
传送，加载和购买，为102，这是完美的订单，是个系列订单，对，1完整，1个线上来，早上醒来，(鸣)，传送100，做101，购买101，然后这一个醒来，传送101，做102，购买102，漂亮。
102就在这里，我得到的订单是什么，就在这里，好，对，像这样，或者任何地方，这些订单都没有完整，其实任何地方，这些订单都还在进行，而这些订单，没有完整的订单，任何时候，这些订单，都在这些订单下面。
这是关键，只要这些订单，在后面，这些订单，都可以在这里，或者在那里，任何地方，所以主意是，在理论上，他们两个都在传送100，他们都认为，他们在传送这些订单，并且在连接，然后再回到，对的101，但事实上。
他们两个都在串通101，而没有人能够，加上第二个订单，所以没有人能够做102，Adam，所以没有人能够，开始向前连接，在最开始的时候，在计划之前，在计划前，把价格给定下来，所以它不会出现问题，好有趣。
你连接这个，这是一个有趣的问题，问题是，有没有方法，向前连接，所以他们能够得到，对的价格，不仅是向前连接，这是一个有趣的解决方案，但你必须，基本上说，这必须在，在另一个订单之前完成，这就是他说的。
目前没有办法，去做这件事，我会告诉你，如何做到，但没有方法，去做到，所以，我们会给你，教你如何修改，但目前。
这并没有办法，所以这就是问题，问题是，我们在进行一个竞争，我给你说一句新的话，叫做竞争，他们两个在竞争，为了更新，而他们正好，遇到麻烦，他们两个，都失去了平衡，一个人，必须完全完成，才能做到。
这叫做竞争状况，所以我们看到，写下来，竞争状况，这就是现在发生的，这是问题，竞争状况，给你一个不决定性，因为谁，看谁赢得竞争，是给你答案的，那天，明天，下次我运行，是另一个人赢得竞争，所以发生的是。
看看，这里发生了什么，pi+=，是和说的一样，pi=pi+someid，所以发生的是，如果这总是这样，这些，这些都运行，我们叫做自动化，意味着它抓住价值，然后保存价值，不过是不够平衡，那你就没问题了。
但是发生的是，一个人，读了pi，然后在那个，那个组件，那个线，完成pi+someid的，右侧，看，pi+someid，发生的是，有人，进去，然后读了pi，在那个组件完成之前，所以我们看到的是，现实是。
它应该，更大，它应该更大，所有的资金。
应该更大，数据其实，并不成功，因为它们互相争吵，正是我们所见到的一样东西。
所以我们如何认可这个，你有一个麦克风，问题是，限制了共享资源的资源，给一个演员，只有一个人，可以一次次地剪辑文件，否则你又会遇到同样的问题，人们拿着麦克风，在同时试图说话，所以解决方法就是转过来。
一个人拿着麦克风，一步一步地说话，同时是一个好练习的方式，对于教室等等，所以这个概念叫做锁，可以利用锁来控制，共享资源的资源，你只需要一个锁，一个人拿着锁，你拿着锁，你才能拥有麦克风。
所以，int lock，0是开锁，1是锁，所以我们开始，我们来谈谈锁，看，锁不等于0，这意味着，等待锁释放，锁不等于0，1是锁，0是开锁，所以这里有个图线，它就在这里，直到锁变成0，当它完成时。
你设定锁，锁是1，然后你能够利用共享资源，然后你把锁释放，在最后，所以这里有个小图线，在等待锁变成0，当它完成时，它就会掉下来。
然后你设定锁，然后你把锁释放，在最后，所以这里发生了什么，准备，看这个，这个说，锁是0，它们两个图线，在等待锁的过程中，在等待锁，看这个，我会笑，看这个，好的，这个说，好，锁是0，到这里。
但是它还没有设定锁，以为它拥有，锁意味着你拥有，这个在等待，它看到锁是0，因为计划刚开始，所以这个，但是它设定锁之前，有些拖延，结果发生了什么，谁在笑，左边的说，我拥有锁，我拥有共享资源，右边的说。
我拥有锁，我拥有共享资源，它们两个在一起，在说同一种数据，这是，没有人理解，所以这就有点好笑，然后它们两个，设定锁，好的，我做好了，我们都很好，我们都以为，我们拥有锁，你看到吗，我试图修改，它不修改。
这是一种竞争状况，为了，锁，这还是一种竞争状况，这不，这不可行。
我喜欢，这是一种竞争状况，两个链接认为，它们设定锁，这个问题没有解决方案，甚至没有在工程师层层，我们需要介绍新的指示。
来修改它，这不酷吗，所以，结论，时间到，1100，OpenMP是一个简单的，C的平行延伸，我们看到平行4，是一个线，你需要修改，C是小的，C是学习的，不是很高级，容易出现麻烦，所以注意，竞争状况。
结果设定，不够好，你不想要竞争状况，我们会谈到，如何使用，安装层面控制，来做这件事，幸好有C层面控制，安装层面控制，我们需要安装层面控制，来修改它，我们下次再见，谢谢，呜，好，(最後。
我也是差一點就忘了關掉燈)。
P41：Lecture 31： Parallelism III： Cache Conherence, Performance - 这样好__ - BV1s7421T7XR
在前面的方式，这次让我们一起干吧，欢迎大家来到61 C，让我们像往常一样从计算新闻开始，我发现了一张很有趣的纸条，你知道量子计算将彻底改变我们对计算机科学的看法，当它最终上线时，每个人都可以使用。
事实证明，你可以通过亚马逊访问量子计算，我不知道我最近才学会的，这是一个新闻，有一个新的计算公司叫Q时代，它加入了亚马逊的云计算，让你可以访问，这是个令人兴奋的新消息，另一个量子计算技术的提供者。
我们试着坐在前面，我们今天试着坐在前面，如果你们都能到前面来或者到前面来，你想坐在这个区的前面，看看我们能不能让每个人都看到这两个部分，如果你需要一些空间，前面都有缝隙，但每个人都尽量到前面来，好啦。
谢谢你，所以在这里，亚历山大基斯林说，量子计算的冒险之一是你可以对量子比特层进行编程，所以你不必把它们都用完，也就是说你不必拥有整台电脑，当你得到你的时间，当亚马逊，谁负责排队这些请求，说好的。
你该去拿电脑了，你不必用整个东西，我想在以前的化身中，你必须保存整个东西，现在你可以说，让我们用这两个人和那四个人比赛，也许这个8对那个16个量子比特，一定是两个四个六个量子比特是件大事，他们在八肘内。
几年前的四个量子比特，所以他们到了两个六的事实是一件非常令人兴奋的事情，您可以构建不同原子的不同迷你集群来并行计算，关于并行性的进一步讲座，所以我想考虑使用量子计算是非常令人兴奋的。
如果你不知道量子计算的基础知识，所有的电脑，所有的计算都是并行的，他们一起奔跑，所以不是一种线性算法，让我们搜索密码，让我们尝试进行密码破解，所以我们要有，哎呦，顺便说一句，这些量子比特处于叠加状态。
他们不是零就是一，他们在中间的某个地方，这真的是量子的一个基本问题，嗯，信息是它的那种在中间，只有当你问，它缓存什么对齐到零一，但它处于叠加状态，直到你问它值多少钱，这真是令人着迷的东西。
其中一个很好而不是喜欢，让我们搜索那个不起作用的密码，那是密码，现在的情况是，如果你有一些量子比特，它在同时搜索他们所有人，所以如果我有一个3位的密码，我有3个量子比特，它实际上在，它们同时的叠加。
真的很迷人，那东西是怎么工作的，有课程，我想我只是在这方面做了一些建议，量子计算的高级课程，由我们的同事乌梅什·瓦齐拉尼教授，因此，我建议任何有兴趣了解更多量子计算的人，好啦，让我们开始吧。
女士们先生们，本单元最后一课，此序列线程级并行性，第三部分，很高兴见到你们很高兴看到大家坐在前面，有更多的能量真是太令人兴奋了。
希望一切顺利，上次我们离开我们的英雄，我们对这种竞赛条件的问题感到震惊，如果你还记得，我们试着把这把锁，你抓住锁，说如果我有锁，我可以访问读写变量，但问题是即使是抢锁也有竞争条件。
这就是我们上次遇到的问题。
所以说，我们全面回顾，你到前面来的大照片，顺便说一下，如果你进来，我们会试着把每个人都派到前面去，如果你能做到，那就太好了，MP是C的简单并行扩展，所以这是一个很大的十英里回顾，你们都知道，看。
这真的很容易，你加一行，平行四，整个for循环是并行的，瘫痪在所有这些软件线程上。
最终映射到硬件线程，真正美丽的务实是如何做到的，被不知道是什么的编译器忽略了，P是你在块中打破for循环，您将每个线程分配给一个单独的线程，所以如果最大值是100，如果你在浏览一个数组。
你会漏掉一些东西，我不知道，这是个好问题，这是个好问题，Python或其他语言自动为您做这件事吗，这取决于语言，Python中有一种方法可以实际请求，这叫做多处理，我想这叫做多处理模块。
所以你可以明确地做一些，但这样做，语言特征取决于你得到的，将取决于，取决于您选择的语言，所以是的，是这样的，我们只是在这个世界上生活和观察，但是请一定要探索Python中的多处理模块，我玩了一会儿。
挺有意思的，所以四圈分开，如果您有一个有一百个线程但有两个线程的数组，然后希望其中一个核心得到零到五十的分配，第二个是零到四十九，第二个是五十到九十九，原因是你想让每个核心，利用那个缓存。
受益权，你希望能够有时间位置，横扫的空间局部性，你不想让他们随机出现，抓住阵列的一部分，给一个数组的连续部分，那东西可以从，如果您有块大小，它将受益于这个块的大小，你的左一或左二缓存。
这就是现在一切都走到一起的地方，嗯，对于o p感知编译器，您必须具有相对简单的形状，做点聪明的事，好啦，所以对运行时来说是必要的，为了能够确定有多少循环迭代，分配给每个线程，这也是真的，你不能做那种。
我们称之为，呃，我们叫它臭C，就像非常丑陋的C，有去，断，回，你不知道怎么跳出来，你得一直这样，做你的工作，然后让我们出去，在平行区域之外做这件事，在平行区，只要用你的for循环非常干净，然后这样做。
总的来说还好，不要跳出任何语用块，他们基本上是这么说的，好啦，好啦，所以我们讨论了一场数据竞赛，我们有两个核心试图更新一个变量，就像圆周率的计算，每个人都想把他们的计算。
他们计算曲线下面积对圆周率的贡献。
你想说，好啦，这是个问题，因为你确实想说圆周率加等于我的贡献，但是圆周率加等于圆周率加一个值的问题。
所以你在读旧的值，你在给它增加新的价值，然后你把它放回去，问题是，两个人可以抢旧的价值，将他们的作品添加到旧的价值中，两者都覆盖了它，你将失去其中的一笔捐款，这就是我们上次在比赛条件下看到的。
我们不喜欢那样，所以我们必须通过同步这些来避免数据库，好啦，我们想要有确定性的行为，所以我们看到我们有这些锁，但即使是抢锁也有竞争条件。
所以我们该怎么做，所以我的想法是，这是一个关于道路的大想法，也不管用，除非你的硬件里有这个，任何软件级的解决方案在海平面上都不起作用--在风险下也不起作用，五级不管用，你必须添加一条新的指令。
让你做一些叫做原子读取的事情，写它说我要在内存中做一些操作，没有人能阻止这一点，这是一个非常有力的想法，除非你有，否则你不能，我再说一遍，你不能解决争用条件，我们会解决这个问题，用这个新想法看看。
这是做不到的，是的，是的，你在网上也找不到，两条路都行不通好吧，所以我们将能够在一条指令中读写，在读和右之间不允许有其他轴，现在的关键是记住分享的东西，记住每个核心都有自己的寄存器集，他们自己的电脑。
希望你知道这一点，每个人可能都有自己的L，虽然这取决于您的特定架构，但每个人可能都有自己的，其中一个可能有他们自己的两个，他们可能有自己的L三个，但可能是共用的，因为L3通常都很大，好啦。
那么你能做什么，他们是如何交流的，我怎么做，他们怎么能有一个核心，与另一个核心对话，嗯，唯一有保证的共同点就是记忆，这是一个共享内存多处理器系统，所以记忆必须是我们交流的方式，我在这边，你在那边。
两个不同的核心，记忆是我们交流的唯一方式，这就是这个多处理的结束，共享内存，多处理是我们交流的方式，下面是典型的做法，我们将有所谓的原子，寄存器与内存的交换，这是价值，我要的东西是我的登记簿。
我当地的登记簿，我是核心，我的本地价值，我要把这个记在心里，我想和它进行原子交换，其他人都不能夹在中间，这里有一个值，我要把这个值，这样这个值就会进入内存，记忆中的东西在我的另一只手里，好啦，准备好了。
掉期，这就是我所拥有的，原子上，谁也阻止不了，两个指令会有读和写的链接，所以我要换一把锁，然后交换给锁，我们马上就会看到的，好啦。
所以风险五在两个方面都有差异，我们将重点讨论前者，只是交换，就这样吧，所以我们开始了。
这又被称为amo原子内存操作，新指令，你不能解决争用条件，在其他系统中没有同等的弹药，他们称之为测试和设置，在这里我们称之为弹药，好啦，它们原子地对内存中的操作数执行操作，并将目标注册设置为原始内存值。
对呀，所以我想做点什么来回忆，我不是想换，我是说，取这个值，把它放在那里，像个商店，把它放在那里，或者这个主意怎么样，我想在寄存器中获取这个值，并将其添加到内存中，添加到内存中意味着什么。
意思是记忆等于记忆，再加上这个记住加等于，我们之前看到它有麻烦了，我们做不到，加等于内存，等于内存，再加上这个很酷，你可以不被打扰地做这件事，因为它是原子的，不能被打断，你还得到了好处。
在这只左手里是另一只，较早的值，所以如果我出于某种原因需要早期值，我可以这样做，否则我会把它设为零，谁在乎呢，但如果我关心早期的值，不管是什么原因，这些警察就是干这个的，所以我想做一个例子。
我要在这里给你看，我可以做所有这些事情，添加或交换XOR最大最小值和所有这些东西，这里有一个例子，它看起来像什么，然后给大家看一下这个，这是一则广告，所以今天和我在一起，这是我的右手，这是一个临时值。
我想加到圆周率上，圆周率在记忆中，好啦，圆周率在记忆中，我想把这个贡献添加到圆周率中，所以我叫弹药加，它的意思是，顺便说一句，这只左手得到了旧的值，所以不管圆周率是多少，一二三走，刚刚发生的事。
此贡献被添加到内存位置，所以内存是正的等于这个值，我的左手是什么？什么事？是以前的东西，如果我需要，让我们看看这个，我们到这边来，所以这是代码，弹药，加德会得到目的地，会得到旧的值。
RS 1是指向内存的指针，我有，我有一个观点，我想要哪一部分记忆，R2是我想要的值，所以让我来做一个伪代码，T获取内存的旧值，记忆那是，它等于，r 1的x的m，R 1是指针，查一下登记簿。
看看那个地址是什么，RS，R 1是R 1是寄存器保存指针的五位，在我的注册档案里找三个，指针的两位，进入记忆，获取该值，叫它T，把它储存在我左手中rd指向so rd的五个比特中，现在得到它在那里的旧值。
现在我做我的权利，这意味着r 1的x的m得到t的旧值，r 2的x，这就是我想添加的其他三两部分，所以第二部分包含了我对该地区的贡献，我想把这个添加到那个内存位置，由r one rd指向的包含旧值。
准备好了我们来查一下记忆位置，此值，把我的贡献加进去，谁也不能乱来，如果我在乎，这是在你做我的贡献之前曾经存在的旧价值，这是我在这里描述的任何操作，添加或者我正在做这个，使用此指针在此值上，我用左手。
旧的价值是什么，再一次，如果我不在乎，我把它设为X零，没人在乎它，我只是想了解更多关于释放的细节，获取锁并释放锁，我马上就给你看，但是这两个部分的细节，这些命令唱诗班和释放26和25。
你可以阅读更多关于它的信息，我没有花时间听讲座，这是相当复杂的，但你可以读到更多关于获得释放的信息，获得命令的条件，我来教你怎么用它来交换。
所以我可以补充一点，那很好，但实际上更有用的是如何首先实现锁，因为一旦我有了一把锁，我可以做任何事，所以让我展示我做一个锁，没有添加东西的想法，只是交换，记住，如果我不想要任何东西。
除了把这个值放在那里，再抢旧值，只是交换准备好了，把我的新值放在那里，抓住旧的，这就是我要怎么做我的锁，让我们给你看这个，好啦，所以假设锁在内存中，存储在寄存器中的零，锁在那里，因为a是指向内存的指针。
我把锁锁在那里，如果是一把锁，锁就被设置好了，这意味着锁是别人的，如果是零，锁就开了，所以如果它是零，没有人有它好吧，这是一段常见的记忆，你所有的核心，所有人都想抓住那段记忆，把你的贡献加进去。
如果零指向的值为零，那现在就没人和那段记忆说话了，它可以被抓住，这是一个，然后有人在，所以你不能这么做。
所以如果你想给它写信，对不起，这是一个，一定有什么东西被利用了。
就像有一盏灯亮着，就像一个，像个录音棚，灯亮着，当灯光亮起，有人在用它，作为一个类比是有道理的，当灯灭了，任何人都可以使用演播室，就是这个意思，好啦，所以零点指向光在记忆中的位置，所以让我们一起做吧。
我要从零到一，我基本上说T 0，我的暂时价值是1，我想要，这就是价值之一，我想把锁放在哪里，所以一个是价值，我要储存在，就像一个是你如何打开它，我要打开我的一个，这是关键台词，AMO交换T零T一A零。
好啦，那是什么意思，一个零，锁在内存中的位置，T零是我想储存在那里的，我想把灯打开，这是我的灯，我要把它打开，但我要叫交换，那么一个人还没有准备好，去交换，我试着在那里放一个，记住，所以记住。
左手永远是旧的价值，它是什么，如果是广告，它是在广告之前，现在我要拿我的一个，我想把这个塞进去，这是一个，一个是现在的旧价值，我要检查什么，我的下一句台词是什么，我想看看以前有没有人拿过。
那么我在检查什么，这个是1还是0，我想要什么，如果我想得到它，我希望它是零，我希望它是零，如果是一个，我该怎么办，继续尝试这个权利，继续尝试，一直试图交换它，直到它为零，直到t 1为零，力矩1为零。
那意味着我拿到了，这有道理吗，这意味着它是零，我得到了，所以看这里，我们走下一条线分支不等于零，一个人回去，继续尝试得到这个，所以我会继续尝试，这是我的一个，代表我对光的控制，你知道的，录音棚，锁。
是录音棚的锁，那怎么样，是啊，是啊，是我做的，好准备好了，把枪放下，好啦，我们会看的，是零吗，如果是零，会发生什么，这条线是干什么用的？如果是零，这说明分支不等于零，所以当它是一个，我一直在尝试。
参见分支不等于零，当它是一个的时候分支，回去，继续尝试，当它为零时会发生什么，它掉下来了，我们慢慢走，当它为零时，这意味着我得到了它，下一行是线程有锁，所以那个小小的旋转等待，继续努力把一个塞进去。
直到它最终归零，这意味着它是零，我拿到了，事实上它是原子的，意味着没有人可以插手，所以所有其他核心也在努力做到这一点，但只有一个会成功，不会有种族条件，这种原子记忆意味着不会有竞争条件，有趣的是。
点aq表示我正处于获取阶段，我在32位指令上设置了获取位，我得到了这个东西，这是一种在最低层次上正确排序的方法，所以现在我有锁现在在代码下一个，它是我的，没有人没有种族条件，我锁住了。
我拥有记忆的控制权，什么记忆，不管我在做什么记忆，我很幸运，不管锁代表什么，我拿到了，现在这个块可能是零，因为这就是我要说的，零可能是这个东西，但关键是，那是我的锁交换释放，当我完成后也是这样。
当我做完，我如何释放锁，顺便说一句，我真的得，如果你不打开锁，就像有内存泄漏，就像那样真的不酷，使用零号房间，把灯打开，我在用，然后开着灯离开，你离开了房子，灯亮着，但是房间里没有人。
你做的最后一件事就把它留在上面是没有任何意义的，你要做什么，你最好把灯关掉，所以你做的最后一件事就是AML交换，你告诉它释放x 0 a 0，零是锁所在的地方，X零表示商店。
这里的一个零和x零表示我不在乎它曾经是什么，顺便说一句，我就知道是一个，我知道它是一个，因为它是一个，因为我拥有它，我把它寄给了一个，但我在乎它曾经是一个，我根本不用。
所以我说X零是那种在他们之后得到它的RD，这有道理吗，所以你基本上是旋转等待，试图阻止他的，我的一种是当它是一个的时候，我一直得到一个，这意味着别人有它是灯亮着是的，灯还亮着是的，灯还亮着，哎呦。
灯关了，这意味着它是我的，我被这个密码弄糊涂了，那个核心是唯一一个拥有这个空间的人，那不是很酷吗，目的是避免竞争条件，问题是目的是什么，避免比赛条件的问题必须是一种方法，我认为是原子的低水平。
为了防止我们在演讲的最后一部分看到的，我们有三十分钟的时间，两个核心需要做同样的事情，但是因为读和写之间有一个延迟，记住，像读这个值，我把它放回去，那是竞赛条件，让我们做一个，我们来做一把锁。
在那里我有一个1和0，即使我得了1分和0分，旧值是多少，你看它，把我的，我会有一个种族条件，只有当你有这个原子允许，在那里没有人能进入阅读和交换的中间，它被称为测试，并设置了类似的想法，因为没人能插手。
我可以保证这把锁能用，这确实有效，这就是一切的运作方式，谢天谢地，但现在我们没有非决定论，这个想法是，你知道的，我一直在运行这个圆周率贡献程序，我们有所有的比赛条件，所以价值在变化。
就像我一直失去捐款一样，因为人们互相抨击对方的贡献。
太疯狂了，这种锁的想法是为了保证一个核心拥有一个串行。
记忆的一部分，就是这个意思，只有一个人能同时做这件事，好问题，是呀，问题是它能跑得更快吗，它跑不快了，它实际上跑得更慢，因为在那里没有其他人可以做任何事，就像它说的，通常你们都只是并行工作，这不是不。
没有人在这个特定的事情，任何人都不能打断这件事。
所以它实际上运行得有点慢，这不是更快，这是中断的同步，你知道的，当锁为零时，不是零，将锁设置为1，做关键部分，然后释放日志零，这是我们尝试过的旧版本，啊，让我们在软件中做一个变量，毛茸茸的，毛茸茸的。
我们在C中，让我们把这个想法相同的块，但又一次，那是行不通的，我们看到它们为什么工作了因为它们都在检查你们俩为什么锁会在这里，为什么因为两个人都抓住了它，他们都认为他们抓住了它，他们不会都抓住它。
你不能让两个人认为他们有，这就是问题所在，种族意味着，他们都认为自己控制了共享资源，没有任何意义，他们都有权进入，他们会互相抨击对方的价值观，说不通啊，所以那不起作用，解决办法是这样的，这是一段代码。
你看到之前的负载指数T 0 1做我的交换，草不等于尝试和就在它下面，现在锁上了，我拿到了，这个电话在阿莫级别的风险五，与阿莫版，现在保证我控制了那个关键部分，现在只有一个核心可以拥有关键部分。
临界意味着只有一个人可以同时得到它，然后我用释放器解锁了它，我存储一个零，现在我又把灯关掉了，这盏灯是我们用来处理这个关键部分的，如果我有我的代码的某些部分，说只有一个人可以在该代码，不管那碰巧是什么。
也许它在读取数组中的十个值，不管是什么，但只有一个人在一个核心，一个可以做到这一点的硬件，你就是这样设置的，这就是你释放它的方式，检查灯光，当你抓住它的时候，这是你的，做你需要做的一切。
我保证只有一个核心可以运行，曾经很酷，原来如此，这是个好主意，我们还有很多要谈的，但这只是个开始，我们能这样做很好，但关键是你要面对的一个事实，除非我们增加弹药操作的风险，五个调色板。
我们解决不了这个问题，那是个好主意，所以我们确实加了，我们确实解决了，我们都很高兴，今晚我们可以睡个好觉。
那么这看起来像什么，我可以看到，让我们看看海平面，现在呢，我们离开海平面了，开始了，我放大，因为它有点小，我们还没弄清楚，把房间里的灯关掉。
所以看看这个。
OMP锁，我做了一把锁，我初始化锁，不管锁是什么，我不在乎，这是一个抽象，我在这里初始化锁，我们去那个线程号，内部没有旋转等待，那边是树枝，我等于z，它的旋转在下面等待，所有，我要说的是，锁，很酷吗。
我知道我要按顺序做，这将打印出我在顺序部分需要做的任何事情，太漂亮了把锁打开，然后很明显你要做的是，把灯关掉，这是解开锁，打开这里的锁，相当不错的交易，如果你能把锁毁掉。
因为你不知道你用的是什么存储设备，你得确保自己收拾干净，所以你破坏了那里的锁，好啦，就是这样，所以做一把锁，初始化它，这是多么酷，得到线程号，废话废话，设置锁，在关键部分做任何你需要做的，又拆又毁。
很好的方法，亚当，十字架的方式，所以你不知道，也许有人你觉得这个房间，是啊，是啊，这是正确的，我不知道要多久，它会说，设置设置锁定你，你刚才说，我得等，我不会这么做的，系统会等待，的。
电脑会说核心在做什么，在临界区花了很长时间，它拥有这个房间，它正在为它需要做的任何事情录制一个长视频，你不明白，所以在你进入那个房间之前，所以你不知道，这一条线实际上可能导致很多很多个时钟周期的等待。
直到你得到房间，完全正确，这就是你想要的，我不在乎会慢一点，我只想保证，这不是不确定的，它是一个确定性的程序，一旦我拿到锁，没有人做比赛条件，我很乐意等待以避免比赛条件。
一个很好的问题，向你展示我指出的所有事情，让我缩放一下，这很酷，我很兴奋能和你分享这个，现在我们知道如何处理同步和避免竞争条件，孩子，那是一段时间的麻烦，好啦，所以通常同步。
您有更高级别的编程构造OPP有杂注，顺便说一下，我强烈地鼓励你，如果你真的在乎这个，也许是为了项目，四个轻推轻推眨眼眨眼，有一个学习教程，关于OMP的更多信息，如果您需要执行更多的操作。
而不仅仅是一个简单的for循环，我在课堂或锁上教过你，我在课堂上教过你，你还需要这些吗，有一个巨大的美丽的教程，他们把开放的MP小组，打开MP组织将其放在一起，在底部，你还有别的事可以做。
关键部分和原子部分，有阻隔就是命令，在并行中你可以做很多事情，您可能需要对此进行更细粒度的控制，杂注下的所有这些特征，允许你这么做，你玩它，从这里探索你需要的任何东西，我只是给你看一个基本的。
如何设置一些块，它们还提供私人变量约简，有很好的文件，所以打开它P是相当整洁的。
好啦，这是我的批评部分，记住，我们回去吧，我们试着做这件事，每个线程都在添加他们的贡献，两个圆周率，记住这就是他给我们带来麻烦的原因，让我们回到这一点，看看代码是什么样子的，我们要做的就是，看这块表。
这是在一个语用上看，多酷啊，我还在平行区，这是语用p平行。
整件事，这个块叫做平行段，我加一句。
这是一个关键的部分，说只有一个核心可以写，一次可以访问那条线路，这就是问题所在，上次，一切四环都很好，对圆周率的贡献是麻烦，所以我们说好，让我们通过让每个核心都有i的π来解决它，每个核心都写到圆周率。
然后我得把它们都加起来，那不是很好吗？如果有办法公开MP，不必做圆周率数组，但只有一层，我们只是在尝试最简单的情况，所有我需要做的是添加omp临界，说圆周率加等于你的贡献，它的工作原理。
所以这比圆周率数组要容易得多，我必须每个人都增加他们的份额，我的意思是你可以做到这一点，如果你需要做什么，但这容易多了，天哪，真漂亮，它几乎是优雅的，几乎是美丽的，多干净啊。
我真的很喜欢他们开放P基金会的目标，也就是最小化您需要更改的代码量，基本上是一个工作的串行程序，那个，当你平行的时候，你加上两条紫色的线，现在使它平行，挺酷的，所以我很高兴。
这是关键台词，让我们谈谈僵局，我喜欢这张照片，你可以看到这张照片，这是一张照片，我不知道这是在哪里拍的，但我相信这是世界上最糟糕的僵局，它是一个四向交叉点，每个人都想左转，但是在底部有一辆公共汽车。
你能看到这张照片吗，我就是喜欢这个，但是想象一下，想象一下看着你的房间，想象一下你得到了，试着去工作，看着这个，我来让你看看这个，你得明白这样有多好没人能打动所有人，这辆巴士是整件事的关键，这就像。
有一个游戏叫做，它叫什么，是这辆红色的车，这是一个塑料游戏，现在呢，这是一个滑块方案，红色的东西需要出去，它叫什么滑出幻灯片二进制艺术使它，这是个游戏，没人玩这个游戏，一辆小塑料车，他们需要出去滑出去。
你知道以前玩什么游戏，它叫什么，游戏的名字怎么样，没有人，反正也没人知道，你看情况有多糟，你被困住了，会不会卡住了，即使有锁，答案很不幸，是呀，这就是所谓的死锁，所以死锁是一个系统，你有。
也许是因为你有一系列的障碍，整个系统实际上不会移动，就像照片上一样，有一种叫做用餐哲学家问题的东西，这是一个非常棒的，有五位哲学家，每次坐着，每个人都有一张桌子，每个人都有，呃，两个器皿，右边一个。
左边一个，所以说，所以这是算法，思考到左叉子可用，当它是捡起来，当左叉子可用时，把它捡起来这对筷子有用，因为你需要两根棍子来做一顿饭，然后叉子，我不知道他们为什么给他做叉子，帝国主义。
我想在找到合适的叉子之前，当它在的时候，把它捡起来，当两把叉子都拿着的时候，我不要你再叉了，用筷子可能更好，太傻了，把叉子换成筷子，当两个叉子保持固定的时间，然后把右叉子放下，把左叉子放下。
从头开始重复，是啊，是啊，所以不管出于什么愚蠢的原因，每个人都需要两把叉子才能吃东西，所以你要等左边的，等待合适的，当你得到它，吃一点时间，然后把它们都按这个顺序放下来，如果并行运行，有什么可能。
这是常有的事，每个哲学家和我一起去，抓住左边的叉子，每个哲学家手里都有一把叉子，很饿，每个哲学家都在等待正确的叉子，永远不会到来，你明白了吗，你得吃两个，每个人都抓住左边。
算法说每个人都在并行运行这个程序，好吧，这五个人都在运行这个，所有程序并行，每一个都很好，我的工作是等待正确的岔路口，我可以有两把叉子做一些叉子的事情，我不知道，也许你把我拉走了，我不知道该怎么办。
K的两把叉子，但每个人都在看着这个差距，没有人会释放它，因为算法上说除非你同时拥有，你吃了一点时间，没有僵局，好啦，所以强有力的想法，那么解决办法是什么呢，你有，我有，我们就说头脑风暴吧。
您有解决这里死锁问题的方法吗，轮流做麦片，命令他们这是一种方法，把订单做好，你知道的，最古老的哲学家，你知道的，把它分在这里，你得吃东西，第一批，两叉都吃，吃完后把叉子都放下，下一个哲学家就会这么做。
所以这是一种方法，您可以正确地序列化它，很有效的解决方案，序列化它几乎总是有效的，那太好了，回到平行之前的日子，还有什么办法，如果我们想保持平行，怎么做呢？更像是更多的叉子，这是另一个很好的答案。
在滚动中，这是正确的，更多的叉子像，把叉子翻倍，你懂的，每个人都有吃的，太疯狂了，有更多的资源，我喜欢它，如果我们没有，我们不能改变那个，还有什么办法，是啊，是啊，告诉我你，是啊，就像如果你。
如果你等了一定的时间，而你实际上没有吃东西，但你拿着叉子，把它放下，等着再看一眼，所以随便找个时间放下叉子，如果你只是拿着一个，所以你打破了这一切，以一种最终会有效的方式，这样就能清除木头堵塞了。
但你得等适当的时间，我是说，你也可以，你知道的，就这样发生了，等待着，然后在别人注意到之前再抓住它，所以你必须能够与之合作，不管怎样，有很多方法可以解决这个问题，但基本上是你有一些随机性。
如果你意识到你不是在逃跑，然后你想离开这里，你说喜欢，让我放弃所有我不需要的资源，因为其他人可能在等他们，然后再等一会儿，也许四处走走，也许在街区里散散步，然后回来看看我能不能有我的资源，我需要这样。
如果你发现你在拖延时间，只是把它脱下来给它给人们，如果你需要，这是解决这个问题的办法。
这就是僵局，就是这样，我受够了僵局对话。
如果要计算代码运行的速度，这是做到这一点的一种方法。
P得到W时间代表墙时间返回，逝去的，墙时间（秒），每个线程测量时间，不能保证两个不同的线程同时测量，时间是从过去的某个时候计算出来的，所以减去其中两个调用的结果，基本上这里有一个非常酷的事情。
如果我说去墙时间，我不知道它是用什么量的，是从上月上周开始算的吗？我不知道它会，因为它是未知的，你计时的方式，有些东西是，你要两个，我说好，开始了，这里是结束，我减去，这就是花了多长时间，所以说。
我不在乎，它是从什么来测量的，我只关心，如果差异是正确的，所以我可以说是时候，从九百开始的微秒数，或者从2000年开始的几毫秒，我不知道它在做什么，但如果我减去其中的两个，那是经过的时间。
所以只要用两个电话来做你的延时。
到目前为止还有什么问题吗，我们谈了很多，我们找到弹药了，我们已经想出了如何摆脱比赛条件，我们谈到了僵局，我们讨论了如何计时，挺酷的，东西，让我们来谈谈大的，20分钟共享内存和缓存。
好啦，你见过这个图片处理器和捕捉器，你有一些互连网络，然后你就有了记忆，这张照片和你之前看到的一样，试图侧身，如果你把头转向右边，记得吗左边是内核右边是内存和iOS，让我们面对同样的画面，好啦。
但是你有一些互联网络，它允许所有的缓存和处理器进入内存，然后通过共享的方式，瓶颈，哪个是连接网络，所以你希望那真的很快，关键是它是一个共享的连贯记忆，这意味着他们都访问了相同的内存。
我们将使用相同的内存空间。
到这些核心中的每一个，硬件线程在相同的内存空间中工作，所以总的来说，如果我提出某种程度的并行性，或者我有一个新的架构，这是一个并行的架构，这是三个问题，你可以要求任何提出新建筑的人，好啦。
你有不同的工蜂，他们会研究一些东西，第一名，他们如何共享数据，这些工作如何共享数据，一般来说，你总是可以问这个问题，第二，他们又是如何协调工作的，这些都是一般性的问题，你可以问任何人。
如果我说我有一个新的酷炫的并行架构，问这三个问题，第三名，有多少处理器，能养活多少工蜂，好啦，所以任何提出新事物的人，问这三个问题，把这个写在你的QA表上，你会喜欢听起来很聪明。
好啦，第一个问题是最简单的问题，我们只有一个地址空间，我们刚才说，我说过作为一个单一的地址空间，2到32字节的内存，每个核心都能接触到，一样的，同一个共享的，不像另一个，一样的，第二，我刚说你协调。
我想我们在记忆之前就看到了，它们通过记忆协调，这是一个瓶颈，你得去萨克拉门托，是呀，你去萨克拉门托协调，就是这些弹药，内存交换，你将进入记忆，我交换的是记忆，用于共享数据必须通过同步原语进行协调，锁。
我刚才谈到了一次只允许一个进程访问数据，虽然那是评论，今天所有的多核计算机都是对称的共享内存，多处理器。
我说你之前说过瓶颈这个词，我再说一遍，内存是瓶颈，即使只有一个处理器，这是一个瓶颈，我们如何修复它的缓存，让我们看看能不能在这里修好它，每个酷的人都会得到自己的缓存。
每个人可能都有自己的L一个可能有自己的L两个，也许L 3有点复杂，现在被共享，但在未来可能是一个核心上的单曲，L三个和一个共享的，L四，谁知道未来会怎样。
使用缓存减少对主存的带宽需求，每个核心都有一个本地私有缓存。
这是变得复杂的部分，我记得的，两节课前的点击器问题，最让硬件和软件设计师头疼的是什么，当我们平行的时候，记住答案是什么，好像百分之九十的人都相信，这就是我们要做的，现在我们正在研究为什么这这么烦人。
为什么这么头疼，每个缓存都有一个私有的，每个核心都有一个私人现金，你看你得说，为什么会有麻烦，你知道为什么会有麻烦，有一个共享的记忆很好，共享内存MOS保证。
但现在突然间你做了一份私人副本，我的L和URL不一样，一个和版本不一样，现在也许他们对同一块内存有不同的值，因为记住你在缓存记忆，那只是复制品，如果他们不一样呢，不好，真的很糟糕，所以保持连贯性是问题。
如何在同一页上保持所有这些缓存的一致性，如果你愿意，在同一个街区的坏名声，如果你能看到，我说佩奇，这是个虚拟内存笑话，好啦，一两个星期后你就会明白这个笑话了，好啦，回到这个，那真的很有趣。
我们可以在这里做得很好，我们去只缓存错过，必须访问。
共享的共同记忆权，你是一个缓存命中，你拿到了，你在用你当地的东西工作，哦，缓存现在错过了，你得出去找一个新的方块把它装进去。
这就是问题所在，好啦，所以让我们做一个这样的样子，我喜欢这个小动画，一点乐趣，动画，游戏过程一和二阅读，一千的内存位置零，价值二十，开始了，一号处理器，它的内存地址是一千，它将值读取到这里。
我们去循环循环，它进入缓存，不在那里，进入记忆，转到内存位置，一千，往回走，20个进来，你把标签装上，或者相当于说一千，二十元，我是说一千个标签中的一小部分，你就说一千二，现在你有了自己的副本。
我们都很高兴，教授，两件相同的事，这只是暂时的阅读，开始了，它不在缓存里，进入记忆，同样的事情等等，等等，二十块，把它带回来本地副本20本地副本，大家都很高兴，谁开心，让我们点点头，你很高兴吧，没关系。
他们都在读二十个，因为你只是在读，阅读真的是如果整个世界都是一个阅读，这是件很容易的事，我们必须把所有的复杂性都找回来，它就不必处理它了，肮脏的人必须处理这一切，那是因为权利使事情变得复杂，阅读很棒。
你有副本，那是个很棒的复制品，这是一个很棒的网站，本地浏览器缓存，阅读的网络，只复制喜欢，哎呦，有一份纽约时报的版面，你那天早些时候读过，你不确定纽约时报改变了它，你不能改变它。
所以我们所有人都会有它的副本，没有人只关心。
当有权利的时候，有问题吗，所以我们现在开始，我刚才说的话，写入问题，所以过程为零，它总是进程或零，我身边的痛苦写着记忆的位置，千加四十，谁预见到问题的到来，你看它慢，像慢吞吞的，就像慢动作，就像意外。
来了，就像这就像一个，就像摩托车开得太快，带着红灯，你知道这是不好的，你看到了，牛慢了下来，不，在这里，我已经在这里给你看了，我们去一千，它想写一个四十，在里面吗，不，所以它写的是四十，因为它正好穿过。
这就对了，我应该问你一个问题，它正好穿过正好穿过，它写信给四十个，好啦，我们做得很好，一切都很好，右火车失事，垃圾箱火灾，这是最糟糕的，因为在这种同时发生的事情中，号码应该是四十，我们以为是二十个。
我们以为北极星就在那里，在那边，四十是四十，问题是处理器一和处理器二，还以为是二十岁，真的很糟糕，所以我们必须再次考虑如何解决这个问题，缓存一致性，这就是你在这里看到的，那些缓存不连贯。
他们不是协议，如何解决现金一致性问题。
就是这样，看看，把滑梯命名为，缓存一致性，所以建筑商店。
现在呢，你现在穿上你的建筑师套装，你不是软件程序员，你是建筑师，你在建立一个系统，你怎么解决这个问题，你的工作是保持缓存的一致性，所以我们开始了，当任何处理器都有缓存时，错还是对。
通过网络通知其他处理器感兴趣，所以这意味着这是一个秘密渠道，就像一根松动的线聊天，像个暗道，与其他处理器通信的方式，嘿嘿，也许这里有问题，休斯顿，我们现在有麻烦了，如果他们只是像你刚才看到的那样阅读。
你可以让很多人都有它的副本，但当有权利，你得检查一遍，使其他副本无效，如果你无效，那实际上还是有效的，因为那样你就会是唯一一个有四十块钱的人，没有其他人有20或1000左右，顺便说一句，你会很好的。
我们说的不是地址，我们说的是一个，高速缓存和内存之间的传输单位是什么，一个街区不仅仅是那个槽，是整条线，是整个缓存线，你得把整个街区压扁，好啦，不仅仅是那个特别的，只是存储元件，一千个不，他们装的整块。
里面有一千个，那就是，你知道的，一千分，对不起，那里面有四二十个，但它是它在哪里，那个块的表示，那是一千个，抓住了成千上万的人，有一千个的网，如果你在做鱼的类比，在这里，我们从一个处理器写入事务。
现在看其他缓存，可以窥探，这是一个非常有趣的想法，窥探就像我在嗅，我嗅到了一个共同的互联，检查他们的标签，那不是很有趣吗？它们是有效的，无效，在另一个缓存中修改的相同地址的任何副本。
所以我们开始了，硬件如何保持缓存的一致性，每个缓存跟踪缓存中每个块的状态，情况如何，有几个不同的，让我们说一点点，一些州，我认为这表明，它就像一个有限状态机，你们分享的几个不同的州意味着。
让我们想想所有这些，就像，我动画的第一部分，我有最新的数据，所以我的一千是二十，这是最新的其他副本，其他缓存可能有副本，所以我有一千两，你有一千两，你有一千两，每个人都有一千两，我们很好，那很好。
我们只是在读书，我们很容易，就像简单的案子，好的读数，那是共享状态，所以我的部分会说它是共享的，就这样，我知道，只是为了让人们知道，你的状况如何？啊，我的状态如何？你在互连网络中询问其他事情。
你的状况如何？我被分享了，也就是说我有一份副本，但其他人可能有副本，也是，那很好，这就是共享的意思，他们都是，它可以在修改后的。
是另一种状态，最新数据，没有其他缓存有副本，这就是我，和我在一起，我写一个40，没有其他缓存有副本，我得让他们另外20个无效，所以其他的，扔掉你的二十块钱，相同的千个内存地址，扔掉你的二十块钱。
我要修改一下，有本地的，有这个，还有这个，实际上很有趣，好吧，写内存过期了，这意味着它又回到了右后卫系统中，我们其实很喜欢他们，如果你还记得我们喜欢右后卫系统，上面写着我给你看了正确的方法。
我之前一直在回忆，在动画中，这在右后卫系统中有效。
在右后卫系统中，记忆实际上已经过时了，就像普通的右后卫系统一样，只有一个处理器。
意思是你的记忆可能过时了，你有一点脏，上面写着我的本地缓存副本，最近的副本和内存已过时，肮脏意味着记忆是肮脏的，不是我的缓存更新鲜，记忆很脏，内存是旧的修改，会说我想，我是零号处理器，想写四十个。
我要让你的副本失效，然后我有修改过的版本，记住他还不知道这件事，因为我不想去萨克拉门托，所以右后卫说，不要进入过时的记忆，但我有唯一的副本，修改意味着我有唯一一个脏的副本。
好吧，记忆是肮脏的，但我有唯一的副本，那是现在的活版本，好啦，所以现在这有点复杂，然后你就可以拥有这些状态。
顺便说一句，你可以忍受这些州，你可以分享它，动画被共享或修改，共享或修改，你可以更优化一点，如果添加到更多状态，它变得更复杂一点，呆在这陪着我，我们在伯克利发明的，顺便说一句，所以这有点酷。
我给你看看这个，每个缓存跟踪每个块的状态，所以每一个方块，每行，它有这些部分，到目前为止共享或修改的这些状态位，我要在州的数量上再加一些位，我可能会考虑，其中一个叫这个有点复杂，但和我在一起叫做独家。
最新数据，所以我有最新的数据，没有其他缓存有副本，就像改造过的，写内存是最新的没关系。
所以两者的区别，修改内存之间的区别是过时的独占。
说记忆是最新的，所以我是否写回了记忆，这是一个小小的微妙之处，或者不是，避免直接进入替换块的内存，那其实很有用，这意味着如果我知道我的身份是独家的，这意味着修改，这意味着记忆是同步的。
如果我必须替换那个块，我可以把它换掉，因为记忆是同步的，如此排他性，实际上节省了一个内存，就在一个街区的替代品上，替换好的，因此在读取时应用数据。
而不是去记忆，所以如果我想读，我不做记忆，可以在那里抓住它，现在业主更复杂了，又是这个，我得读这个，因为人们总是把，所以我拿了这个，我试着多加点这个，让我慢慢读，看我们一起做，店主说我有一份最新的副本。
其他缓存可能有副本，记住共享状态，在股票之前没有人真正拥有它，就像每个人都平等地分享它，我加上一个想法，可能是有人说，我其实是它的主人，现在呢，你可以被分享，但我是它的主人，和我在一起，这是什么意思。
此缓存是具有缓存行有效副本的几个缓存之一，其他共享的，可能也有，但拥有对其进行修改的专属权利，它一定要看这个，它必须将这些更改广播到其他缓存，共享线路，和我在一起，这真的很酷。
这种自身状态的引入允许肮脏的数据共享，我不可能把纸条传给丽莎，传递纸条传递纸条给其他人，这是改变的值，那不是很疯狂吗，我还是老板，我想换我的20，所以二十个都是对的，所有二十个，我想加到40。
但我是老板，所以我赌四十，然后我传递到其他缓存，四四十，我无视，记忆不是那么快和酷，我不去萨克拉门托，他们得到了特别的秘密纸条，四四十，他们都更新自己，我还是老板，但现在他们又一致了，现在我们又连贯了。
那不是很酷吗，没人欣赏好吧，那很酷，没有主存，在使所有共享副本无效后，缓存行可能更改为修改状态，所以如果我想修改，然后出于某种原因去修改，说我想以某种方式记住，修改不同于拥有和排他性，我能做到。
但后来被修改了，手段，没有其他人有副本，记住修改过的，上面写着，没有其他人有副本，所以如果我想去修改，记住你们都是始终如一的，我将被修改，说你能抹去自己吗，你现在能抹去你自己吗，你现在被抹去了。
我被改造了，现在我有了唯一的话题，因为我被改造了，废话，废话，或者通过将修改写回主存来更改为共享状态，如果我现在把我的修改推到主存，我们又被共享了，这个FSM的一点微妙之处。
自己的高速缓存线必须用数据响应窥探请求，所以如果有人问你有有效的，是啊，是啊，我去看看，让我看看你的资料，看看你有什么有效值，所以不仅仅是，我在传纸条，我也可以要求和服务，如果你是老板。
您可能有一个请求，你的现金额是多少？哦耶，当然在这里，我把它给你，所以有一个非常聪明的优化，我在那里来回传递音符，告诉你新的价值是什么，或者响应您当前的价值，业主可以做到这一点，所以这是一件很酷的事情。
所以这叫莫西改装，拥有独家共享，我是残疾人，这就是你所看到的所有状态的可能性，所有的状态意味着，这意味着，你能拥有一个人，我们一起去吧，你能拥有一个人吗，哪里是我的，啊，给我在这里给我一些爱。
我能成为一个O吗，你是一个O，没有，我能成为主人吗，你被改造了，没有，我能拥有你的独家新闻吗，没有，我可以被拥有和你分享吗，是的，是的，有道理，你看，我只是在解释任意两个处理器的两个状态是什么。
任意两个核心，你懂的。
好啦，非常酷，所以唯一有趣的是两个人可以分享。
无效除外，你说的唯一绿色是，两个人可以共用，右下角的绿色，如果我被拥有，你可以被分享，拥有和分享，只有这样才能让这些都起作用，共享和拥有，拥有和共享，同一个还是共享共享，这就是我要说的。
其余的都是无效的，所以有三种可能的状态，在这里拥有和分享，拥有和共享或共享和共享，你就这点本事，你能做的只有这些，是一个莫西协议，也被称为伯克利所有权协议，谷歌熊市。
没人兴奋，好啦，所以现在有了COSO，好啦，加载时间，好啦，现在有了现金一致性，一千个人来到这里，我们去一千，处理器零，我想写作，我想现在的海关想写过程，零处理器零发送消息，请将您的其他副本作废。
他们使他们的二十岁无效，然后我写一个40。
我很好，所以这就是我告诉其他人做某事的想法，没时间问问题，对不起。
我有一个点击问题，或许下次我们可以从，在开始的早期，我不想失去这个，这是个很好的问题。
我想我有答案了，所以我跳过了，好啦，缺少缓存一致性是问题所在，这是什么意思，我试着在事情发生前完成它，两个处理器希望访问同一个块的两个不同位置，但他们是独立的，绿色的一个通往绿色区域的通道。
粉红色的一轴，粉红色的区域很好，对不对，块有32个字节，他们在阅读和写作，他们会说这是一场冲突，即使他们写的是记忆的独立部分，因为他们在同一个街区，这是个问题，假设我在写地点，但你写了整条框线。
你不能只写到一个地方，你写到整个街区。
所以方块会在两个缓存之间乒乓，即使处理器正在访问不相交变量，这就是所谓的虚假分享，看起来他们住在同一个街区，他们不是，他们在访问同一个街区的不同部分，但东西系统认为他们在分享它，他们不是。
如何预防，嗯，我们看到三个C的强制能力冲突，现在最大的一个叫做连贯性。
两个不同的处理器在一个块内访问，不同地区，但实际上系统说对不起，你不能那么做，你的标签会和，你要重写，同样的事情，我不知道你在访问什么，所以那叫小姐，那是个问题，这也称为进程之间的通信。
一起研究并行程序，你以前从未见过，这以前从来都不是问题，并行程序，现在我们讨论两个并行程序运行同样的事情，操作同一块的两个不同部分。
有麻烦，连贯性失误可以主导总失误，最后，我看了最后一张幻灯片，Omp是种子的并行扩展，有所有这些扩展，私有变量的并行，减少额等，线程级别，并行，哈希一致性，执行情况，共享内存，即使有多个缓存的多个副本。
虚假分享，你真的认为你在分享，但它不是，你真的不是，你跑进了一个街区的独立部分，但系统很抱歉，你分享它是为了平，敲打东西，读写，阅读，小姐们，小姐小姐小姐小姐，块大小是问题所在，它想得越大，它就越大。
两个东西写到同一个块的可能性就越大，这让我很麻烦，如果你做一个较小的块大小，你没有那么多，较大的块大小，两个人写信告别同一段记忆的机会，同样的麻烦，所以块的大小是你的问题。
周末愉快，开始跑过来大约一分钟左右再见。
