UCB CS61c 组成原理中文笔记（八）
P47：Lecture 36： MapReduce, Spark, Amdahl's Law,Date-level Parallelism - 这样好__ - BV1s7421T7XR
欢迎回到这个系列讲座中，我们将教你一个新的抽象叫做mapreduce。
以及它在多种语言中的实现，但特别是叫火花的蟒蛇非常令人兴奋。
但首先我们要做的是教你这个基本原则。
其实我们之前应该教你几堂课，称为阿姆达尔定律。
实际上它被称为阿玛尔令人心碎的定律，其中一部分是你努力。
你不能越过这条法律，所以令人心碎的是。
你不能超越这一点，但让我们告诉你它是什么，所以模型如下，你有一些增强。
你想升级你的GPU，升级内存升级，计算机升级的某些部分。
某些系统的某些部分，其实不是，即使这条法律也适用于，实际上并不局限于电脑。
所以模型如下，你有一些增强。
我们称它为e，你想测量你的速度是多少，是不是快了两倍。
总体情况，总体情况，三五，快十倍，快一百倍，基于此增强。
有一个非常简单的方程，我们强调如何计算。
所以有e的速度是没有e的执行时间。
除以e的执行时间，你可以想象对了，如果时间减半，那么速度将是两倍，想象一下，就在膨胀的时候，哦，我的天哪，做这件事的时间到一半了，哎呦，这是一种挖洞的新型铲子，好吧好吧，这是过去所需时间的一半，所以说。
在底部的一段时间，一半的时间在上面，如果你想通了，时间将是一半，另一半放在这里，然后两个空翻，它变成了2的因子，加速有意义的两个X，所以我们不，我们经常，我们其实。
我们鼓励我们的六个一C学生和所有学生不要使用百分比加速，因为人们只是把数学弄错了。
或者现在速度提高了百分之一百五，你想用1。5 x，只是更容易理解那是什么，好啦，让我们来了解一下我们是怎么想出来的。
所以让我们想想你面临的每一个挑战。
尤其是那些有部分可以并行的代码。
就像一个公开的议员，这里有一个平行的部分，还有一个不是关键的部分。
或者是连载的部分，可能是安装部分和收集部分，在最后，关节部分，分叉在那里。
关节，但危险的部分与此不同，所以事情是这样的，我们要说的是，我们会说增强不会影响一部分。
所以财富就像一小部分。
所以s是一个分数，这些都是小数部分，又是一个任务。
这不仅仅是计算机科学和计算机工程，但它确实加速了剩下的部分。
是1减去S，这就是为什么s是分数，这是一个百分比，一减。
这是一个百分比，所以1减去s是平行瘫痪部分，以及任何可增强的可增强的部分。
那是1减去s的百分比。
分数和s是没有被改变的分数，它的速度是p的1倍。
P大于一，好啦，这就是这里的希望，所以现在让我们来看看他们看起来像什么，你注意到这里的s是不变的。
所以这里是我的，没有改变，好啦，但是减去s的部分要小p的一个因子。
所以我们得到的是有e的执行时间，是没有e的执行时间，这是一种时代，所以这是因为它没有改变，既然这个S还在这里，这并没有改变，所以这就是我，这已经被分发了，如果你把这个相乘，让我们分发这个。
让我们把这笔钱分成这笔钱，你得到的执行时间没有e乘以s，即这部分没有改变，看那部分没变，然后是旧的处决时间，可并行化的部分是这个分数，这是旧时代，不管这次是什么，也就是他们那个时代的处决时间。
较小的分数，即1减去s除以p，所以e的加速度就是1除以，因为这是种小说的正常时间，我们将1除以s加1除以s除以p，这是驱动amdah定律的基本方程。
所以现在让我们把它拉出来，同样的方程式，以不同的方式毁掉它，你得到了速度，时间是1/s是未加速的分数。
1-s/p是被加速的分数。
在完美的世界里，当加速因子达到无穷大时。
如果我有一百万个核心，万亿个内核。
一万亿个帮手在做这个，那个项归零，你只剩下一个。
就这样了，所以速度不能再大了。
事实上，在完美世界中等于1/s，在这里s是分数。
这是连载部分。
好啦，让我们一起做这件事，例如，程序五分之四的执行时间可以加快。
增加了16倍，那很好，80%的代码是可瘫痪的。
想想可以加速16倍。
那太棒了，整体提速多少，我十六岁了吗，我五十岁了吗，不能超过16个。
我十五岁吗，什么样的打击，我接受了什么打击，我没有加快整个程序。
所以让我们好好解决吧，结束了，谷物的分数是多少。
嗯，那是百分之二十或二，事实是什么，那是平行的，八号井，八点要快16倍。
所以现在，零点五，所以第二点加零点五就是第二点，五个。
1/2，五是四，你把所有的钱都花在了16倍的改进上。
但在一天结束时，你只进步了四倍。
令人心碎，这就是我们称之为阿玛尔心碎定律的原因，当我们再次看这个的时候，是一段代码，又来了，s是s和p s，一减s或平行部分，嗯，是啊，是啊，部分总是分数，好啦，所以在这里我看这个原始的时间。
我有一段基本并行的代码，我们做得很好，每次我添加更多的核心，这是我要在这里得到的核心数，每次我添加更多的核心，我要把这个平行的部分按那个因子缩小，所以现在这个黄色的家伙有一半高，而这个黄色的家伙是。
这是四分之一高，我试着用这种方式做图形，但这就是我的想法，所以当我看处理器的数量，我看到的是取决于平行部分，我有不同的曲线，你知道在完美的世界里，加速多少，我可以得到这样，如果并行部分只有代码的50%。
嗯，那么连载部分是一半，所以我只有两倍的速度，所以我可以有无限多的处理器，只有双倍的速度，那是惊人的无限数，当然那百分之七十五呢，如果75%是平行的，然后四分之一考虑一下，那么四分之一是连续的。
这意味着只有四倍的速度，下一条曲线说90%的平行度，嗯，这意味着十分之一，因此10倍的速度，百分之九十五怎么样，那只是那只是一二十块，呃是连续的，所以只有二十次，所以倾斜，二十次已经很好了。
但你几乎要达到95%的平行度，你还没来得及把速度提高20倍，更不用说，我是说，看核心数量，我们有六万五千六万四千个帮手，是啊，是啊，只快了20倍，这就是阿玛尔令人心碎的定律。
所以这个故事的寓意是做所有的工作，你可以有很少的串行代码，一个很小的设置代码，整个平行，如果可以的话，然后很少在最后聚集和加入，能够发布你的结果，就是这个意思，如果你真的想最大化它，它有点像头顶。
这几乎就像你支付的间接费用，我有生意，我还得付房租，那是间接费用，所有的利润，我把开销因素，所以不管你做什么，尽量减少开销，代码的串行开销，所以你们几乎都在一个平行的阶段，尝试解决令人尴尬的平行问题。
在那里很少的设置和初始，也许像一个例子，初始化所有的和，你还记得我们是怎么加圆周率的吗，将它们全部初始化为零，那不是平行的，但尽管它可能是，但那是连续的，然后计算出所有的馅饼，那是工作的一大部分。
然后一些小的部分聚集在一起，在最后把它求和在一起，好啦，好啦，我是洋娃娃令人心碎的损失，对不起，很抱歉成为布拉德坏消息的传递者，但你得知道，你得学着点，好啦，这可能是在婴儿数量处理器的完美情况下。
想象一下它的其他元素，一个比另一个慢，而这个失败了，我们将谈论所有我们得到的话题，呃，得到云计算的话题，以及我们如何处理这些失败，我们以后再做，好啦，我们下期视频再见欢迎回来。
我们将讨论请求级别和数据级别。
并行，在我们不断重温这张照片之前，你已经看过了，当我们继续分享平行的奇迹在所有不同的表现形式，今天我们要讲两个元素，一个是最高的并行性，即并行请求，我要在电脑上搜索猫的顶级想法，在高层是如何运作的。
我们还将讨论一个叫做mapreduce的计算模型，如果我从功能上考虑我的数据，我可以这样想，我有一个由一百万个数字组成的数组，我不介意直接说把它们加起来，把它们都平方怎么样，然后把它们加起来。
我可以想到抽象让我们能够处理它，从纲领性的角度来说，没有循环，把他们都平方，所以我在考虑一次处理多个数据项，到目前为止，你一直在想，那只是意味着SIMD，这意味着你要对浮点的四个向量进行操作。
你知道一个更宽的矢量，也许四个浮子宽，你说把它和另一个矢量同时相加，这就是我们过去对那个盒子的看法，但现在我们要从抽象的角度来思考这个盒子，一百万个数字的平方计算可以由我来完成，把它发到一百万台电脑上。
或百万核，有些模型在一台电脑上有一百万个内核，我把它承包出去，不知何故，它让这些家伙中的每个人都抓住了一个数字，是核心吗，是一台关心每一个元素的计算机吗，每个工人元素将抓取数字，把它平方，立即归还。
一切都神奇地回到了它，所以你还可以这么想，这种新的抽象允许您思考，在那个模型中，我把四个向量加起来，我说了加四个矢量，所以即使我有四个花车，我把另一个加到另一个浮点数上。
我只是把一个矢量加到另一个矢量上，它实际上是同时添加了四个浮点数，那真是太好了，抽象中的相同思想，处理并行数据的想法非常简洁，所以我们将在这个系列讲座中讨论一些非常强大的抽象，那么什么是请求级并行性呢。
如果您曾经想过Web服务器必须处理什么，这是请求级并行性，一秒钟只有数百或数千个请求，当这个数字超过机器所能处理的，它变成了分布式DDoS攻击，它变成了一种攻击，系统现在被钉在。
只是试着呼吸试着四处走动，它刚好足够拒绝服务请求，您可以进行拒绝服务攻击，分发这个，很多通勤者都专注于一个服务器，通过让它，试着处理一下，所以当它在这个舒适区时，这就是我们正在谈论的。
但你可以超越这一点，你会在1961年了解到这一点，拒绝服务攻击，所以我想你是一个服务器，你的工作是，你知道的，对请求的反应，顺便说一句，你可以做到，制作自己的Web服务器真的很有趣，我鼓励你考虑一下。
制作一个Web服务器，提供一些有趣的数据，也许你有一些传感器，那就是做一些有趣的事情，或者拍照，或者做一些事情，我不知道，也许测量你家里的东西，一株植物长多少，你制造了一个能够响应攻击的服务器。
米奇跟上了，响应请求并提供数据，这是植物今天长得有多大，或者这是我的相机看到的，玩那个，探索它是很有趣的，现在你们都变得更流利了，计算机科学家、黑客和辛普森一家都在玩这个，这样做很有趣。
每项请求在很大程度上都是独立的，如果你向世界发布你的植物种植数据服务，你可能有世界各地的人，即使你知道，从空间站打你的服务器要求它，我想知道那株植物现在有多高，有点刺激，但其中一个因素是。
所有这些请求大多是独立的，也许是，你知道的，一人，你知道的，经常打它，因为他们想绘制一张图表，所以他们打它，也许您的服务还允许您查询过去的增长值，所以你做了一张小桌子，所以你可以给出当前的增长值。
也许是过去的，所以也许有人在浏览所有的有效日期，经常打齿轮，但大多数时候他们基本上是独立的，大多数时候，它们是从大型数据库或大型数据中心读取的，在某种程度上，你又在收集和提供数据了，你将在，CS一86。
如果你想学习如何建造一个这样的，呃正式的，但你可以，你可能也会很容易地卷起你自己的，他们很少涉及，上面说它是严格阅读的，编写跨请求的数据共享或同步，所以大多数情况下，这些只是大量的这些请求同时发生。
主要是他们的阅读，主要是他们的阅读，有时是写的，但主要是他们的阅读，嗯，如果你在处理一个广场谁处理广场，想想你使用的所有服务，阅读的，写，你知道的，脸书广场，我在编辑一些东西，我想把它储存起来。
让全世界都看到，嗯，那个云软件，我们会学到一点，另一堂课云仓库规模计算如何工作，如果您有新的Web服务，当然会有，你不只是读书，你将能够以社交媒体的方式在其中互动，所以这很重要，也是，显然那里也有权利。
竞争很容易在一个请求中和不同的请求之间进行分区，所以你知道的这些事，每个请求都可以是原子请求，我会成为一个说，再次键入此新建并单击编辑，顺便说一句，如果你以前见过这个，两个人在编辑同一个广场的帖子。
他们会说，啊，有冲突，因为你们两个都想打同一个东西，一定有办法处理的，竞态条件，谁先写，广场是一个很好的方式，并有一个晚上，做得很好，所以它已经在做了，如果考试中有问题，许多助教试图回答这个问题。
我去开门，这个学期我已经收到好几次了，所以这个软件仍然必须能够适应这种情况，也是，下面是谷歌的一个例子。
呃，查询服务体系结构，你点击谷歌网络服务器，它做的第一件事就是做一个拼写检查，抓取一些广告。
我是说，从谷歌的角度来看，广告是最重要的。
因为那是你寻找的货币化的地方，我想在伯克利找到最好的鞋子。
嗯，你，赌上你的全部家当，在伯克利附近卖鞋的人。
就是，它将被激励向谷歌付费。
所以他们可能的研究，你知道回报。
嗯嗯，有一个链接到他们的，他们的公司很早就出现了，还有一个。
有一个完整的方式，如果我真的需要，你知道我的资助者告诉我。
我需要提高我的销售额因为一些事情，所以我要给谷歌多一点钱。
所以它更加突出，或者它出现在偶数，你知道更远的搜索，甚至运动鞋怎么样。
嗯，我可能得付钱才能穿上那里的运动鞋，所以广告服务在那里真的很重要，它首先要去查找它的索引。
它已经建在里面了，顺便说一句，很多人天真地认为当你输入一些东西。
然后它开始搜索Web，一点也不，它一直在网上爬行，在庞大的索引数据库中不断构建庞大的索引。
所以它知道文件可能住在哪里。
此索引服务器，顺便说一下，注意它们是平行的。
这个是这样画的，表明有很多这样的人，嗯，这不可能击中一个非常快的机器。
这打击了很多机器，它又回来了，它正在被聚合。
所以有点，有趣的是这里发生了什么，它是如何通过那些。
所有回来的请求，这是你的页面，我去了，好啦，太好了，我要拿一份文件点击这个。
然后我可能文件也会从那里得到弗雷德，也回来了，太令人兴奋了，谷歌。
当然有一个正面头版的建筑，嗯。
它在做拼写检查，它在做广告，那真是件大事，嗯提起，接下来要找出列表是什么。
你的，你可能到那里的链接，以及被存储和保存的文件。
并为索引服务器提供饲料，数据级并行，你以前见过一点，内存里有数据，你有一点点，你有一个数组，我想用，我要攻击的所有核心，所以这是非常非常常见的，你没看到的，我们将在这一系列的讲座中介绍很多内容。
跨多个磁盘的IS数据，我有这么大的，我们称之为大数据，我有这么大的数据，我无法融入记忆，我得装进磁盘里，我可以把一部分读入记忆中并使用它，但那是最大的，我可以的，那么你怎么能，即使它们不只在一个磁盘里。
一个大的，比如说射线盘，你还不知道什么是突袭，但我电脑上的一大组磁盘，看起来可能是一个虚拟磁盘，但实际上和抽象一样多的磁盘，但没有，它太大了，一个磁盘都装不下，它必须适合许多磁盘。
也许这些磁盘生活在磁盘生活在云中，这就是所谓的云存储，孩子，你怎么会，那就太好了，一定会很好的，如果我们有一个抽象，能够键入一些命令，让它能够在这些光盘上工作，这就是我们在下一系列课程中将要教授的内容。
Mapreduce是一个非常强大的想法，抽象，现在的软件基础设施和开放源码软件基础设施，谢天谢地，我们都可以玩一个小实验，允许您跨许多许多磁盘工作，这是一个文件对文件的模型，非常非常令人兴奋。
今天的讲座和系列讲座是关于mapreduce的，一个非常聪明的实现，也叫火花，我们会在接下来的几节课中看到，我们在那里见，欢迎回来，我们终于来了。
MapReduce很高兴成为第一个向你解释这一点的人，如果你没看过，所以mapreduce是一个抽象，这是一个非常简单的，我说简单，与过去相比，我们以前要做的，MapReduce天数，数据并行编程模型。
为可伸缩性和容错性而设计，这里的关键是容错性，如果你是在，不仅仅是核心，核心在大多数情况下不会失败，但是孩子，当你去机器，那些机器生活在其他国家，他们失败了，网络瘫痪了事情发生了。
我不能把它承包给一千种东西，千种不同的机器，希望所有的千种和期待，我希望他们都是一千个，但我希望所有的人都能平安无事地回来，在某种程度上不失败，很多事情可能会发生。
尤其是当你把机器的数量增加到一个很大的数字时，你会有麻烦的，在核心的情况下通常不一样，所以对容错性的担心就少了一点，但当你生产一台多台机器时，顺便说一句，我们称之为分布式计算，由谷歌首创。
他们定期处理两个5PB，相当不可思议，对呀，每天PB字节的数据，嗯，有一个新的开源项目，我会说很新，它是，几年前有一个新的开源项目，哈杜普嗯，雅虎使用，Facebook、亚马逊和许多人。
这是一个基于Java的框架，我们喜欢Hadoop的功能，它对谷歌有什么用，谷歌使用它的mapreduce框架做了很多很多事情，你得建立你的指数，你的团队能够处理谷歌搜索，谷歌新闻机器翻译的um聚类文章。
街道地图，你是怎么做所有的街道地图和多层，并且能够处理缩放因子和所有这些，嗯雅虎，搜索雅虎，垃圾邮件检测是一个大问题，脸书数据挖掘，添加优化，垃圾邮件检测，许多事情都属于，可以想象映射阶段和还原阶段。
我们一会儿会讨论这些是什么，这里有一个他们用的东西的例子。
他们以前在Facebook上使用MapReduce，这是现在这个以前是可用的，不再可用，但是脸书词典。
我认为谷歌也有一些东西，在那里你可以输入一个单词，你可以看到。
曾经发生的相关事件，那么什么时候人们在寻找不同的东西，所以今晚宿醉时人们说派对是一件有趣的事情。
所以今晚的派对和宿醉，今晚的派对是黄色的，宿醉是蓝色的。
你注意到宿醉经常随之而来，经常在今晚的派对后面达到顶峰，只是人们在打字。
但你知道什么时候，这就像它的频率，顺便说一句，其中一个派对发生了。
你看得到吗，啊，有一个相当大的派对当，啊，我不知道万圣节派对，新年晚会对吧。
也许你知道，假日，圣诞节，宽扎光明节，一切都发生在这里。
但是分布在那里，但是孩子，似乎每个人都在新年的万圣节聚会，二月份什么都没有。
三月或四月，所以听起来我们需要在那些日子里引入更多的国定假日。
只是分发派对，嗯，这里有一个设计目标，顺便说一下设计目标，这最初是出于工作，杰弗里·迪恩和桑杰·格瓦特在谷歌所做的，几年前，他们写了一篇著名的论文，最，自那以后系统中下载量最大的论文，从2004年开始。
这就像十六年前，截至这段视频，这个想法是，它可以扩展到真正海量的数据量，数以千计的机器，每台机器多可能有多核嗯，在里面，数以万计的磁盘，你可以想象处理的数据很多，所有这些成本效率，所以他们学到的一件事。
我们会在仓库规模计算课上讨论这个，他们没有买最高端的机器，他们带着商品机去了，他们说你知道每美元的价值，对呀，每美元周期，每美元的加工周期更便宜，如果你选择商品机，让体积的价值真的有所帮助，而不是很好。
让我们买最高端，就像那种疯狂的游戏玩家，高端游戏机，液冷和你知道的每美元的高，事实并非如此，如果你没有一场比赛，我想为一个系统播放，我有这个，我的8K屏幕最好的东西，也许这是一个很好的价值。
但当你试图计算大量数据时就不是了，那是每美元的计算计算处理，那不是正确的决定，商品机是有趣的，他们开始建造自己的，这很有趣，商品网络，嗯，容错是这样的，容错怎么办，嗯，你所做的就是重新发送。
这也是互联网上发生的事情，如果我发送一个数据包，我得不到回报，我刚刚又发了一次，那是我们在网上学到的，这就是tcpip为您所做的，tcp确实在这么做，在这里给你的那个词，我们要做的就是。
我们会重新发送请求，可能不是同一台机器，可能会寄给别人，嗯，但我们通过重新执行来处理容错，再发出去，发送请求，我把它碎成了一千块，回来的有九百九十九人，一个身体不好，派别人去，顺便说一句。
也许还有比这更早的暂停，与其等到99年，九十九回来了，然后把成千上万的人送回去，他们会说你知道吗，我要早点放弃你，发送出去，这样在等待之后，所有的东西都可以在同一时间回来，我们发现它很容易使用。
我们在下级部门有一些任务来做这件事，我们也很高兴能与大家分享这一点，嗯，我们已经链接到院长的论文，我们把麦金瓦特院长的论文，我们已经在621C页上链接了，所以请一定要看看，这里有一个典型的集群，嗯。
每台机器，我们称之为节点，每个节点可能有一个本地光盘，呃，就挂在上面，这是合理的做法，有一个机架开关连接所有这些，我们来谈谈服务器，下节课中的机架和阵列，但在这里，它们都是通过开关连接的。
它能够接受请求并能够知道与哪台计算机对话，它是从哪里来的，它要去哪里，有点像路由器，从某种意义上说，嗯，还有一个聚合开关，做着同样的事情，但不同的是你有一个不同的，允许不同的带宽要求。
一旦你进入越来越多的中央司令部，就像水管一样，对呀，当你家里有水管，管子真的很小，一旦它传到你的邻居那里，它要大得多，从城里来的，它是巨大的，好啦，如果你去洛杉矶，他们有这种溢出，不是这个。
我敢肯定污水也更大，但你知道，如果你，我会考虑处理洪水，你有一点小洪水，这种情况在海湾地区经常发生，而且位置非常平坦，当然是在洛杉矶，嗯，你知道的，哎呦，这是我的邻居，有一条小水沟可以处理洪水，那很好。
一旦它到达主要区域，有一个巨大的，我想大概是，我想二十条车道宽的水流。
在那里水最终会流向海洋，这里也有同样的想法，一旦你离开每个节点，在更高的层次结构中，如果你愿意，这些开关必须非常快，高端得多，他们有一个8G的连接网络，所以你最终会有更贵的，我们就在这里谈费用啊。
更高级别的昂贵得多的开关和连接，因为你是你是，您正在处理更大的数据通道，这是为整体中的每个人准备的，整体可能是整个数组。
所以我们这里的一些数字是一个架子上的40个节点，呃，一个集群中可能多达4000个节点，所以你可能会听到这里的第一个集群，嗯一次又一次，机架内每秒千兆带宽，然后八个从架子上出来，节点规格。
这是一台低端机器，这是它像一对夫妇的年龄，但总比不使用更快的计算机好，正如你所看到的，没有变得那么快，所以也许八个，两场演出，两个千兆赫核心，八桶公羊，大概是十六岁或三十岁，现在两个了，和四个磁盘。
每个大约4TB，所以这是一个有趣的幻灯片，因为我们在第十和第六集一直在做的一件事，在六百人中有一点，但更多的是与您分享编程范例的好处，称为函数式编程范式，如果你用功能性的方式思考。
您的工作是拥有一个具有输入和输出的块，而且没有任何副作用，然后您将能够使用这个mapreduce模型，稍微容易一点，所以我们一直在教MapReduce，我们实际上教MapReduce。
非专业课上CS中的地图和缩略的概念，这种情况很少发生，我觉得伯克利在全国领先，把这些并行计算和分布式计算的想法引入到较低的部门，即使在这种情况下，我们的非专业班，顺便说一句，它与，你知道的。
全世界上千所高中，至少我们有一千名教师在PJC经历了我们的专业发展，所以这意味着这些想法正在被风吹走，这是模型图，地图上说，对一组数据执行一个函数，就是这样，所以我想平方所有这些数字，一二十三和十。
下面有一张小照片，告诉你发生了什么，所以我首先应用地图，但它的作用是，地图上说拿一个函数，通常是单点函数，这里一个参数的函数，在这个简单的案例中，它是一个参数的函数，把每一个数字都取平方。
所以它将这个函数应用于每个返回新列表的人，不是不变异列表，它不是，这是一个不变的列表，返回新列表，其中每个元素都有应用于它的函数，一二三和十，我得到了一个四百九十九和一百，现在我说。
结合+和如何结合再结合，它低于抽象的水平，即它是如何工作的，它是左关联的，右关联的，关联树智慧，谁，希望这是一个，它是树状结构，但这是结合在一起的，这通常是一个二进函数，两个输入一个输出。
这有点像搅拌器，所以这里我只是把它们加起来，所以这里有一个例子，这里是四百分之一，凑在一起给你给你四个一，百里挑九，它给你109，最后是五十分，所以这是一种，我们希望能有个树形模型，谁知道谁知道。
谁知道映射是如何发生的，也许你告诉我，哦丹，我只有两只工蜂，两个核心，两台机器帮你做好，我不在乎，一定会成功的，如果我有两个，这将被分割，你知道一台机器可以做这两个，一台机器可以做这两个，我不知道。
也许有四个，此列表也可以在，你知道在比利，谁知道那名单有多大，很少会有十亿，在岩心工作的工蜂，您的总核心，在您可用的集合中，所以在某个时候它说得很好，把它应用出来，然后回来，然后继续努力。
直到你们都做完，但是从用户的角度来看，我不在乎，这就是这种抽象的美妙之处，从用户的角度来看，我不在乎，所以在一天结束时，我得到了五十分，顺便说一句，这里只有两种数据类型。
这里输入的数据类型和输出的数据类型，这就是关于域和范围的思考，这可以在计划中完成，我们以前一直教我们计划，这是一个方案模型，你们这些拿62a的人知道这个，所以地图和缩小顺便来，我们称之为组合。
我们叫它地图，加起来是十先令和六十一先令，我们教计划、地图和减少是其中的一部分，这是地图，在列表上平方，一二三和十，然后你在那个表情上减去加号，多漂亮多结实啊，Python的语法更多。
但是我们必须从Funk Tools库中导入reduce方法，然后我得稍微定义一下加号函数，然后我要定义一个平方函数，我显然可以在这里用lambda，过一会儿你就会看到了，我们将使用lambda。
我们这样做是为了点燃东西，但在Python中也有同样的事情，这个正方形的地图上的加减，我自动得到五，十，真的，真的很干净，所以这是mapreduce的简化版本，在下一张幻灯片上会变得更复杂一点。
所以让我们真正进入它，在迪恩和迪恩提出的完整的mapreduce编程模型中，我们有一个中间步骤，那是地图和还原阶段之间的一步，中间步骤有一个键值配对，您了解Python中的键值配对。
从你以前见过的任何键值模型，地图是这样工作的，地图拍摄，Map将数据作为值中的一个键，它将处理输入键值对，将数据切成碎片，分发给工人，这就产生了中间对，所以CDB对是通过键设置的，然后按键排序。
每个共享密钥，共享密钥的所有数据都发送到一台计算机，您将看到一个数据，你看到一张幻灯片，下一张幻灯片，一切都会清楚的机器，然后，我的机器有所有的数据在同一键，所以关键是你连接的方式。
你在以某种方式标记数据，把它分配到那些机器上，因为系统说不管你有什么钥匙，我会按按键来协调，所以中间阶段在那里，所以你用钥匙，从某种意义上说，不仅仅是添加更多数据，不要在输入数据中添加更多的工艺。
而是把它分散在，很好地，你可以确定关键分配是什么，并分配它，很好，所以你可以控制它在还原阶段是如何分配的，然后每个人都以平行的方式连接钥匙，然后按机器间的键排序。
然后每台机器都得到一个特定密钥的所有数据，然后用你的减速器处理所有的数据，还有一个减速器，好啦，就是这样，它产生一组合并输出，通常只有一个值在这里，这里有一个例子，面包和黄油问题。
每次我们研究一种新的编程语言时，你好世界，如果你不能说我的事，我的系统解决了，两人抽象策略游戏，我们说解决井字游戏，如果你说我有一个很棒的系统，可以让你更容易地进行并行计算。
我们说给你看单词数单词数成了问题，我们去的是那种去面包和黄油的问题，你好世界，如果你愿意并行程序和分布式系统，单词计数如下，我有一个文本语料库，也许这都是莎士比亚的作品，也许是古腾堡圣经。
也许是所有希拉里的电子邮件谁知道它是什么，我希望能够，为了字数，数字数，为每一个字，为每一个独特的词，我想数数，它的发生，这就是我所做的一切，如果我给你，我有，我知道我想出去，我有两只眼睛。
在这里一做一学，所以这个要做的是标记，记得我告诉过你地图的输出是这个键值对列表，那么它要做什么，它会用关键字标记它吗？是单词本身，用文字分割，这个词本身和价值将是第一位的。
所以基本上接受它进来的每一个字，我只是在它的侧面拍了一个，顺便说一句，关键是这个词，价值将是第一，我把它传递到下一个阶段，排序阶段将对事物进行排序，这将是一个机器为每一个键，所以关键是我做和学。
这将是一个机械师的工作，把这些数值加起来，众目睽睽之下的第一名，有一台机器把所有的数值加起来，又是一号，这里有一个学习，所以做一个我一个做和一个学习机器，他们每个人都做减速器，减速器怎么说，嗯。
查看每个值的这个设置结果为1，对于中间级中间值中的每个V，中间值，我在一些结果变量中积累一些结果，我将结果作为字符串发出，就是这样，数据在分布式文件系统上，这意味着数据不在内存中，数据打开了。
文件上的文件，那些知道它们是什么的文件，他们在分布式网络上，所以他们对我来说不仅仅是本地人，你以为，啊，总是我当地的办公桌，不是这样的，您在分布式文件系统上，意味着他们活着，他们住在那种。
我会说引用中的云，这是我最喜欢的例子，下面是map和reduce的代码，我有，我有一份公正言论的档案，啊在第一档，文件2是空白的，A在第三个文件中，如果一个或在第四个文件中，或者一个奇怪的，第五档。
或者和i，如果映射器做什么，它拍打钥匙和誓言，它一巴掌，你知道它为每个人返回一个键和一个值对，所以它说我要顺便处理一下，它没有理由处理映射器中我能处理的一切，它可以通过并决定不x不发射一些东西。
它所做的是正确地观察，我说的每一个字，它发出，你可以说每一个字，那不是她，所以你把，所以你也可以在那里对你的电话做一些过滤，我是说你在写代码，它把一切都弄脏了，因为它是为每一个W，W发射出所有的东西。
但你可以想象这里有一个过滤步骤，如果你想这么想的话，正如你所想的，哦，我可能会做这个问题，但我需要做一些过滤，这里是过滤发生的地方，你不知道的地方，你不承认你不想承认的事情。
所以现在我所做的就是给所有这些人都贴上一个，现在我在每一个键的末尾都有一个，关键又是所有的字，就是这个阶段，我按关键阶段谈论了小组，也就是说它们将是一台连接在每一把钥匙上的机器，关键现在是五个独特的词。
A或如果或或，什么是减速器，然后所有这些值，所有这些值都被发送到减速器，什么减少了，说出来，基本上它说，把它们加起来，把所有的数字都提高了，无论价值如何，好吧，它有时会忽略钥匙，我不在乎，输出键是什么。
但对这些人来说，我要做的就是输出一个四发出一个字符串，所以从，这在某种程度上，这是本字典，好好想想，作为，整个系统的输出值，这是每台机器都说得很好，我是我是被分配到一个，我的值是4，所以它是冒号，嗯。
我是给她做手术的机器，我只看到其中一个，所以我是你的冒号一号，原来如此，输出是整个系统的一种方式，这就是目标，整个问题的目标是，字数是返回键在哪里的字典，这些话，每个唯一的单词和值是出现的次数。
它们发生在最初的事情上，嗯，这就是这里发生的事情，这是输出，如果你歪着头，下面是钥匙上面是价值，就是这样，这就是你的字数输出，很简单，对呀，好像没那么难，所以制图师，它所做的就是在它的末端扇一个耳光。
减速器说，嗯，我得到了所有的，我该怎么处理它们，把它们加起来，所以真的减少了，另外好的，关键是附上一个，的，制图师，减速器只是拿，只是加，这就是我所做的一切，就是这样，所以字数很清楚，这是怎么工作的。
假设语料库不仅仅是，你知道四个文件，但是一大堆文件，也许这是一个巨大的目录，也许是很多，这怎么行得通，这很聪明，这是系统工程的一部分，一部分，这真的很聪明，顺便说一句，并不是所有的地图都花了相同的时间。
有时你知道地图任务可能，也许你得到的文件比其他人大得多，所以你要比其他人做更多的工作，不是所有的地图都需要同样的时间吗，我有点你知道在我的简化中，在我的简单的正方形地图的例子中，你知道。
平方对你能得到的每个数字所需的时间是相同的，除非你有很大的数字，这些数字实际上是以字符串的形式存储的，但现在你认为，那是个糟糕的模式，地图真的需要可变的时间，因为减速器可能需要可变的时间。
谁知道你认识多少，我在那个模型里加了多少，所以有一个，有线索了，我们称之为，我想一个主控制器，它将地图和减少的任务分配给这些工作服务器，所有这些服务器，就像一个，你知道工蜂，如果你一看到这个。
地图任务一完成，可以为该服务器分配一个新任务，所以这个特殊的工人只被分配了地图任务，这项特殊的工作只是时间地图，也是地图任务，此工作者可以被分配读取任务，因为它在读一个，意义，这是干什么，这家伙说得好。
完成后，我可以开始读入这些值并等待它，我也需要知道男孩，我需要读这本书，所以这也是对进来的那个人的阅读，然后我在读这个，所以当他们现在都做完了，我可以开始减少任务，为什么要等到他们都做完了。
不去想这个是很聪明的，开始减少，所以每个工人，所以这是，这是说看，这些工人是制图员，这些是减速机工人，情况并非总是如此，我基本上是地图一完成，我告诉系统，嘿嘿，我可以做更多的工作，也许我就是工作。
也许这适合我，我是说这样画是为了让图表更清楚，但可能是这个工人被分配去读，然后它会等待和阅读，那么基本上这个可能在这里，这就是我要说的，好啦，不一定要很好，一号工人只是在绘制地图，工人2只是在映射。
你知道基本上他们回到工人池里，工作就在那里，所以有一个需要处理的作业队列，就像你得启动减速器，你得启动下一个映射器，嗯，这里可能有更多的制图者，而不仅仅是三个，所以说，你真是个天才，从这个意义上说。
我是工蜂，我在做一些地图，然后我会做一些减少，可能还有更多的地图要做，我完成了减重，那里还有更多的地图要做，谁知道那是什么，嗯，做了什么，顺便说一句，通常发生的是，不只是一张图一个减，你把它倒了。
这是我从来没有看过报纸，我发现发生的事情是，这里可能有一个地图缩小，进入另一个，映射还原到另一个，所以这一系列的地图缩小，不只是一个，这只是一个问题，我只需要知道这些，可能有几个阶段，做第一阶段。
第二阶段第三阶段，然后你继续处理机器，看着真的很有趣，有一点，就像一个，就像一个仪表板，你可以看到事情是如何处理的，很整洁，所以我鼓励你们看看，如果你成功了，所有数据洗牌一结束，缩减任务就开始了。
也许要把这些洗牌，最后在那里，因为在这个问题中，和以前一样，最后一个映射器可能会对你的减少做出一个贡献，所以在这个特殊的问题中，在完成所有映射之前，您不能进行任何还原，这样我就可以。
我可能暗示了你可以在映射完成之前开始减少，在这种特殊情况下，我当然不能开始加我的，直到所有的男人都成为一个，输入我的机器，就这样做了，在这个特殊的模型中，你得等到所有的地图都做好了。
我甚至可以开始考虑减少，但你可以开始阅读他们的价值观，当然这是件好事，这是我之前提到的事情，呃，如果工人没有反应，嗯网络故障，磁盘故障，硬件故障，内存故障，可能会有很多很多的失败，我只是重新分配任务。
如果一个工人死了，那很重要，执行相同字数的Java代码的数量，如果我们仔细观察这里，正在发生的事情就在这里，它在说，呃，我输出值和1，这是这个的实际代码，我在这里，我的和是零，我是和加上等于那个值。
有点复杂，但本质上这就是我们以前所做的，这就是它的Java代码，就是这样，所以有字数的人，顺便说一句，这大部分都是建立起来的，我们只是把这些东西放在这里，在它的早期部分，嗯，就是这样，很刺激。
字数是一个很好的例子，地图产生了一个非常非常强大的范式，下节课我们要讲，也许有清洁工，比我看着的时候轻，也许三五行代码，如果斯帕克有什么办法的话，我们会看到的，然后保重，欢迎回来。
我们要教你火花，这是mapreduce范式的另一种思考方式。
稍微轻一点的触感，就你要为它做多少编程而言，因此，它是一个快速和通用的大规模数据处理引擎，它来自加州大学伯克利分校，对此非常兴奋，这是一个性能栏，显示特定文件的运行时间，火花从水中吹出。
以100倍以上的速度，部分原因是火花在记忆中工作，MapReduce总是关于磁盘折扣的磁盘，所以你知道，但基本上是映射，我们在处理这样的大数据文件，我在内存中做不到的数据集，我必须，我是说。
我要加载内存，动手吧，但我基本上可以说，输入输出特性的类型总是基于磁盘文件的输入文件的输出，这就是你写文件的想法，那你就不，如果中途坠毁，它，把你的文件写好，你就可以休息了，火花说得好，那很好。
但这不是很好吗，如果我能在记忆中工作，活在记忆中，而且不用付一千倍或更多的钱，转到磁盘的性能惩罚，很痛苦，所以Spark有一个先进的执行引擎，它可以计算出当，它给了你时间计算，挺聪明的，这是非常。
它很懒，这是一个懒惰的评估模型，这真的很好，在内存计算中尽可能多地，易于在scala或python中用java编写应用程序，我们将看到Python的例子，它提供了相当多的高级操作，使其非常容易。
你甚至可以和它互动，您可以与它交互接口，以及一种批处理的方式，mapreduce就是这么做的，但事实上，你可以交互式地玩这个真的非常有趣和令人兴奋，所以女士们先生们，给大家看一下。
这是Java代码，我在上一节课给你们看过，这是同一个词，在蟒蛇中计数火花。
我已经加载了文件，上面还有一条线，上面写着，你知道的，什么文件，我已经加载了文件，但实际处理是先，我通过将文档拆分为单词来平整地图，现在我在某种意义上有一个单词列表。
然后我映射这个单词和1，我现在返回一个单词和1的列表，我按键减少，记住按键还原，所以这不是一个洗牌阶段，这是按键减少的。
也就是说，这些工人元素中的每一个都将再次得到，只是相同键的值被键减少。
意味着每只工蜂只能得到，只获取特定键的值，它对这两个值做了什么，它把它们加起来，女士们先生们，麦克风掉落，所以你不仅比，但你可以做三行，Java在四五行中必须做什么，相当令人印象深刻。
所以让我们来玩一下，所以你可以把这个装起来，我鼓励你也这样做。
这是我要给你看的，但我想要什么平面地图。
如果你不知道平面地图是什么，想解释一下它是什么，为什么我们知道我们需要它，这里有一个叫做邻居的例子。
邻居取号，返回左边数字的列表，我右边的人数，很容易。
我们从SC Spark上下文点开始。
五级瘫痪范围，也就是说我将从0到4。
包容性，从某种意义上说，平行，将其加载到RDD中。
把它放进它的，它以并行的方式存储数据的方式，它存储数据。
好吧，现在叫它R，什么事都没有发生，顺便说一句，这并不是真的。
你知道那个范围，我希望你知道，Python 2和Python 3的范围之间的差异。
是蟒蛇两个范围。
如果你说一百万的范围，它实际上会做一个百万清单并返回。
蟒蛇三系列说是的，但如果你从来不用它呢，把一百万列在名单上太傻了。
但千万别用，所以Python 3采用了懒惰的方法，每次都返回一个承诺范围。
一种叫做“like的范围”的新类型，这叫五射程，零五一，也许吧，上面说得很好。
一点用都没有，如果它立即返回，但是巨蟒二号的呼叫范围是一百万，看看需要多长时间。
巨蟒三号瞬间百万呼叫范围，这里有一个一百万范围的承诺。
如果你想要他们，然后如果你说好，让我好好迭代一下，一个接一个。
从范围中获取一个值，嘿范围，我需要你的下一个价值范围，好这里，它是三个范围，并使用您的下一个值。
这里有四个，这就是工作原理，这就是懒惰评估的工作原理，斯帕克也是这么想的。
那个射程不起作用，所以射程返回了一个瘫痪的承诺。
没有做任何工作，因为你从来没有要求过，只有当你说收集的时候，你是说，好啦，现在你得付风笛手的钱。
你的呢？你的数据瘫痪在哪里，数据在哪里，我们向谁调用。
哎呦，五的范围，快速五的范围得到了一些价值，范围说可以，你有多需要他们，很大的范围会给你这些值。
只有在那一刻，范围才起作用，就在那一刻，平行瘫痪了。
做任何工作，就是这个意思，这是一个非常懒惰的系统，很聪明的方法，这也意味着你可能会有延误。
好像有二十条命令，就像，他们为什么这么快，是呀，因为什么都没发生，只有当你说。
收藏说，好啦，现在我可以做这项工作了，所以只有在收集的时候，它真的会把这些收集起来，试着把它吐回你身上吗。
这是一个非常重要的想法，你明白，所以现在，如果我说我们邻居的地图，它返回一个包含这些三胞胎中的五个的列表。
右边的n减去1，n和n加1。
但它不会这样做，直到我说它只是说艺术，在邻居的地图上，它的精细范围可能超过100亿。
是啊，是啊，千亿，一万亿个R点。
邻居的地图会立即恢复不做任何工作，因为它没有被要求生产任何东西。
然而，如果你说收集，它会试图付出一切，那我应该努力做它的工作，所以如果我说ARAP邻居收集。
它会给你，它会给你一个由五个子列表组成的列表，但我对自己说，我不要五个替补，我想要一张平面地图，我想要一个平面列表，嗯，这就是平面地图的作用，这和地图的想法完全一样，只是它变平了。
不管次级者是从哪里出来的，哪张地图会给你，它把那些压平了，就像它把它们加在一起，所以平面地图和地图返回的东西是一样的，只不过都被压扁了，这有道理吗，我教你的，因为我们会看到这个，当我们看到字数的作用时。
当我们玩字数的时候，我们真的要跑，让我们来一个慢动作版本的单词计数在火花中，所以让我们现在就做这个，下面是《灵感》中的字数，我们已经在一行中看到了这一点，斯蒂芬·科尔伯特把麦克风掉了。
但让我们做得慢一点，这和我之前给你看的数据一模一样，从字面上到不折不扣，同样的数据，这些都是档案都是啊啊，在第一个，然后在第二个上有一个空文件，这就是全部，这些都是之前的数据，在你之前看到的那张照片里。
所以我说的第一件事是W表示字数，等于C点文本文件，给它一个文本文件，那就像瘫痪了一样，但它在读取文本文件，而不是瘫痪Python对象，我说的第一件事又是平面地图，线线点分裂，只要我说有收藏价值。
如果我这么做了，它不会这样做，通常给你任何输出，但我这么说，它给了我本质上，它说我不知道这个，这张平面地图又做了什么，它说我不在乎，什么档案，你就是从这里来的，我只想把你压在一个大池子里。
我们称之为单词池，好啦，一大滩文字，所以我们在这里，这是我所有的话，然后我说，平面地图，顺便说一句，橙色是唯一新的东西，好啦，所以这是所有的白色都是一样的，我在添加点图lambda单词的一个。
它要做的是对这些单词中的每一个，我在1点加了一个标签，这是新的，你以前见过，现在呢，这里三次，现在这是关键，我加一句，减少键λa b a加b，这就是我昨天刚刚复制粘贴的，你从，呃来自火花。
这就是你得到的，顺便说一句，这些没有特别的顺序，显然不是按字母顺序排列的，但呃是一盎司两个如果，呃，三个矿石和一个A，这是我的输出字数，现在我说我把它打碎了，我本来可以在一条线上完成的，我的意思是。
你知道这一点，这可以看到文本文件是W，我本可以说那个点平面地图，然后那个点图，然后那个点被键缩小了，又一样了，就像我之前给你看的那样，很整洁，是啊很漂亮，所以这是一个例子，你说丹它更快吗。
你肯定是平行做的，嗯，我做了件小事，小婴儿的事情，理智检查它。
让我们运行这个东西，假设我要计算一些数字，模拟处理一个大数字。
我拿一个数字n，我将是恰克恰克，在这里做了很多测试，一件事需要很长的一个小时。
好长好长，我是说五秒钟，我是这么说的。
我其实要说，我要睡五秒钟，然后返回这个数字的平方。
所以如果我说十的嘎吱嘎吱，它在105秒后返回，不过，顺便说一句。
你自己试试这个，这是你相信我，如果我说的地图紧缩和范围四。
所以我要把所有元素从零开始平方，零到三。
嗯，如果我只是说，记住，如果我只是说，上面写着，哦耶，返回地图类型否。
我不希望你真的给我价值观，所以我必须列出它的实际值，但20秒后。
有四个元素，四五二十，那是20秒后，这确实需要20秒。
如果你计时，那我只是为了好玩，我说好，让我们在火花中试试，World sc。
四个细R点地图嘎吱嘎吱的并行范围。
五秒钟后收集，五秒钟后我想出了这个。
我怎么说这就像一个愚蠢的小测试，但现在有趣的是，我在一个八核机器上运行了这个。
我很想重新测试这个，我想让你在自己的机器上玩这个。
请玩这个看清楚，好啦。
这能有多大，我只有当我只有你知道，我们知道我们有超线程。
所以也许我有八个核心，那是十六根线，我可以用它有多大。
在这停止需要五秒钟之前，所以继续改变，就是这个大小。
看看会发生什么，这是一种戳进你的机器的方式，顺便说一句，当你实例化Spark时。
你可以告诉它有多少，呃，你想要多少个核心，有多少并行线程。
你想让，所以玩那个玩那个数字，看看当你改变这个数字时会发生什么，看看它是否总是五秒钟。
或者当它超过五秒时，但这整件事在五秒钟内就发生了，这有点好，就像玩那个的标准检查。
所以让我们结束这堂课，你们在本课程中看到的第四大观点是并行性，我们正在以许多不同的方式重击它，事实上，我们今天看到了其中的两种方式，数据级并行和请求级并行，阿姆达的法律令人心碎和不幸。
但这是我们现实的一部分，这是，顺便说一下，不是计算机科学的部分现实，这是什么，任何与这些法律并行的事情都会影响这一点，再一次以无限的平行度，加速是一个以上，S。
这是最大的mapreduce是一个很好的抽象，谷歌使用它，很多，许多人雅虎使用它来进行他们的大数据处理，它是基于文件的火花，是不是更好，它是一个非常迅速的增长，参与Spark的开发商数量正在增长。
顺便说一句，这让你很有市场，轻推，轻推，眨眼，眨眼，别再说了，不要再说了，我鼓励大家学习Spark，流利地使用Spark，玩，在休息的时候玩它，你在这上面加了火花，你说我可以在你的简历上使用大数据。
你看起来是个不错的候选人，就是这样，我们下节课再看，当我们谈论云计算时，挺刺激的。
P48：Lecture 37： Dependability,Parity,ECC,RAID - 这样好__ - BV1s7421T7XR
你好，欢迎回到61 C，这是一个全新的可靠性模块。
这是一个相当短的模块。
我们要触及它，还记得我们早期关于计算机体系结构中六个伟大想法的故事吗，所以说，我们已经讨论了使我们能够构建这些复杂系统的抽象层，在许多许多组件中，我们通过分层许多层的抽象来做到这一点。
我们已经谈到了Morslaw，它使我们能够集成如此多的设备，建造这些复杂的系统，2。我们已经讨论过……的原则，位置和内存层次结构，使我们能够建立这些看起来无限快的存储系统，无限大。
我们已经讨论过并行性作为提高性能的一种方法，在整个课程中，我们也谈到了性能度量和改进的概念，主要通过计算和平均内存访问时间的铁律，但是我们还没有讨论第六个好主意，即通过冗余实现的可靠性。
这就是我们现在要讨论的，为什么这很重要，嗯，我们在日常生活中越来越依赖我们的计算机系统，在纯粹不是很好计算的领域，我们所有的金融交易都是由计算机进行的，我们驾驶着一系列的电脑，是由某种计算机支持的。
我们真的需要关心可靠性，但事实是电脑出了故障，他们可能会暂时失败，我们以前见过，恐怕这些蓝色的屏幕，以及许多其他计算机故障模式，通常在计算机崩溃后，嗯，它可以回来，我们称之为瞬态故障模式。
失败可能是因为代码不好而发生的，嗯，你认识一个人，你知道我们，忘记清理退出功能的不仅仅是学生。
生产软件做到了这一点，有时也是，他们有。
你知道的，说着，你知道的，新版本，而且效果更好，但这些事情发生了，但有时这些失败，发生运输故障，因为硬件上有些东西不太对劲。
硬件出错。
如果这些错误持续存在，在计算机中确实有一些东西永久地失败了。
然后我们经常抛弃它们。
或者我们试图修复它们，如果它们是可以修复的。
这个模组。
我们要花点时间谈谈，我们如何减轻这些硬件故障。
所以我们在介绍模块的早期已经简单地谈到了这一点，当我们，替换系统的故障部分，这种冗余在存储系统中经常遇到，我们在记忆中有多余的东西，但是我们在并行计算机中，我们可能有备用处理器核心。
你会发现在市场上你现在可以买到，八核GPU还是七核GPU，当你看着芯片，它们完全一样，只是八核被禁用了，他们会把芯片卖给你便宜一点，为什么它被禁用是因为它不好，它失败了，不过没关系，你只是少了一点表演。
你有七个而不是八个，你要为此付更少的钱，所以它的工作方式是，你有多个复制品，会有某种投票机制，三分之二的人，也许会同意一加一等于二，我们就当这是答案，这是集成晶体管集成点的进步使这变得容易得多。
所以我们可以有更多这样的组件，现在还有一个陷阱，因为组件比三个更小，他们有一种倾向，你知道更频繁地失败，这并没有增加，故障率没有随着速度的增加而增加，我们可以在哪里整合更多的它们，所以我们可以增加冗余。
另一边，嗯，我们如何改进事情，我们如何减轻这些短暂的故障是，暂时，你知道的，东西可以暂时熄灭，我们仍然可以，在没有它们的情况下继续计算，例如，你知道，数据中心可能会走出去，我是说，可能会有飓风。
可能停电了，互联网可能坏了，数据中心走出去，天气系统消失了，数据中心已备份，我们遇到的另一件事是我们经常使用这些磁盘数组，如果磁盘，如果机械磁盘出现故障，没关系的，因为有办法掩盖那张磁盘。
在架子上有冗余，所以一架子光盘会有备用的，最后，我们可以使用一种特定类型的编码来，我们DRAM的冗余，所以我们的内存芯片，这是一种用于计算机的昏暗设备，如果你仔细看，它有九个存储芯片。
对应于九位而不是八位，原因是第n个是为了表示均等，这种纯度将被用来指示是否出了问题，我们现在要快速休息一下，然后我们来看看如何衡量可靠性，稍事休息后再见。
大家好，欢迎回到我们的可靠性模块。
模块的主题是，我们希望使用冗余来提高可靠性。
但请记住，在每一个计算机系统中，我们需要衡量一些东西，以知道我们是否改进了它，以及改进了多少，那么让我们来看看我们的可靠性度量标准是什么。
所以让我们首先了解计算机系统是如何运行的。
所以它在正常运行中，它为我们提供一些服务。
嗯，但它可能会失败，所以故障。
这和页面很不一样。
故障是计算机系统中组件的故障，或可能不会导致系统故障，取决于它是否被使用，以及是否多余。
还有其他东西可以接管，例如。
所以这个系统将在两个州之间运行，在一种状态下，它运行正常。
所以服务是在另一个状态下完成的，有一个服务中断，从正常操作转移到服务中断是失败的。
从系统中断中返回，这是一个偏离指定的服务回到正常的操作是恢复。
重要的是。
这种情况发生的频率有多高，当我们谈论裁员时，我们需要多长时间才能回来。
我们将看到冗余在时间和空间中的使用。
当你谈到空间冗余时，这意味着我们有一些东西的多个副本。
我们可能有多个计算单元的副本。
或者更常见的情况是，我们将有多个数据副本，数据的多个副本可能存在于DRAM或磁盘中。
在印度更常见的是，我们会有某种代数方法。
添加冗余位，这样我们就可以从硬盘中的临时错误中恢复。
我们经常保留冗余设备。
帮助我们从任何失败中恢复过来。
另一种形式的冗余本质上是时间冗余中的时间冗余。
嗯，这意味着如果有一个失败。
如果计算机系统出现暂时故障。
我们有时间重复计算，我们不妨那样做。
所以如果我们检测到计算失败了。
或服务未完成，我们再来一次。
如果我们完成了，我们会平安无事地恢复。
嗯，我们都很好。
所以这是一个时间冗余的例子。
让我们来看看这些可靠性措施。
嗯，你怎么知道，我们用什么样的标尺来衡量可靠性。
所以第一个也是最常用的是平均失败时间。
它基本上测量了我们需要多长时间。
拿着，把我们当成一个设备故障，或者在同一设备的两个故障之间，如果它们是可恢复的。
另一个指标是服务中断。
服务中断本质上是我们在中断状态下停留多久。
嗯，这是修复的平均时间，同时，故障之间是平均故障时间和平均修复时间之和。
然后我们可以定义一些非常重要的东西。
系统的可用性。
系统的可用性只是平均故障时间。
除以平均故障时间和平均修复时间之和。
我们怎么能。
如何提高系统的可用性，或者我们可以增加分子或者减少分母。
增加平均失败时间是什么意思。
所以组件会停留更长的时间，通常我们会用，我们通常会有某种冗余，除此之外，我们将添加某种容错性，这样如果一个组件出现故障，我们的系统不会崩溃，减少分母的另一个方法是减少地铁的同时进行维修，基本上。
它是关于改进已经检测到的工具，系统中有些东西不太正常，并使其回到正常的模型操作，所以这是关于可靠性的度量，接下来要定义的是这些可用性度量或可用性度量。
嗯可用性，正如我们已经定义的，它是平均时间与失败的比率，除以平均故障时间和平均修复时间之和，但它通常表示为时间的百分比，两者都意味着失败的时间或之间的时间，失败现在是用我们的来衡量的。
计算机系统，现代计算机系统很少出现故障，你知道的，至少这是我们习惯的很少崩溃的系统。
通常假设它会上升很大比例的时间。
在很大一部分时间里，意思是九十九点九九。
有百分之几的时间，9的数目，嗯通常是衡量每年9个可用性的数量。
那是什么意思，所以如果有什么东西90%的时间是可用的，嗯一年后。
那意味着你会倒下，呃，修理三个，六天。
如果百分之九十九的时间是可用的，这意味着它将下降三分，六天，我们每年有三六天的修理时间。
那很烦人，我是说很少有人会容忍这样的事情。
虽然在其他一些系统中，你知道交通可能没问题，你知道的，这是每天运营的公共汽车每年在商店里花费的天数，嗯，3个9表示系统将停摆，呃，每年修理526分钟，真讨厌，但越来越接近被接受，四九和五。
每年3分钟维修，而5个9是每年5分钟的修理时间，嗯，这越来越接近我们的预期，这是我们在这些服务中经常遇到的事情，我们实际上在互联网上使用，我是说，这是命令，4到5个9是YouTube的可用性，嗯嗯。
正如你在看这些视频时注意到的那样，YouTube有时会宕机，其他系统设计有六七个九，你知道的，我们更依赖的东西，这个系统崩溃的代价要高得多，嗯，例子有，你知道的，几年前，当YouTube关闭几个小时时。
YouTube的损失，这基本上是每分钟数百万的损失，好啦，这就是可用性度量。
让我们来谈谈三个能力衡量标准。
我们喜欢以不同的方式衡量。
这种可靠性是。
在一个有许多组件的系统中，我们每年有多少次故障，例如，假设我们操作一个有一千个磁盘的数据中心，每个圆盘的特征是有一千个，十万，嗯我们失败的平均时间，所以让我们看看，这意味着每年有多少磁盘会出现故障。
在这种系统中，那么我们如何转化为MTF的一个可靠性度量。
到另一个可靠性度量，年化故障率，这对数据中心来说非常重要，数据中心实际上会跟踪这一点。
所以我们一年有八千七百六十个小时。
然后我们有一千个磁盘全年都在运行。
我们的平均失败时间表现在我们的。
所以我们要把这个数字除以10万小时。
我们最终得到的是每年87。6个失败盘，平均，你知道的，所以我们必须把它四舍五入，因为一般失败的不是第六点磁盘。
所以有88个失败的磁盘。
嗯，这相当于年化失败率为8。8%。
嗯好吧，那没那么疯狂，这个数字实际上接近我们在实践中看到的，谷歌在2007年发表了一项研究，发现实际的，一场个人驱动的闹剧从第一年的1。7%不等，随着年龄的增长，他们的比例将达到8。6%，超过3%。
你知道的，三岁开车，挺有意思的，有有趣的网站，在线备份服务之一，背板实际上公布了他们驱动器的故障率，然后可能是有用的信息，你可以看看，你想买一个新的驱动器，他们是，它们对现代崛起很有好处。
它们要么是个位数，要么低于个位数，你知道的，实际上是大约一百万小时的订单，在失败和另一个好消息之间的一百万小时，我之前提到过这个，这个驱动器实际上正在变得更好，随着时间的推移，他们的失败越来越少。
慢慢地，但肯定AFR在减少，这里有减少的趋势，还有一个，可靠性度量，嗯，用于不同类型的系统，但是计算机系统必须坚持这一点。
这是时间上的失败，也是第五率的失败，嗯已经用了。
例如，及时为汽车和故障。
嗯，或设备的配合率，是在十亿个设备中可以预期的故障数。
几个小时的手术听起来很多。
我是说，十亿小时听起来是不可想象的，但是想象一下，我们有许多这样的设备同时工作。
所以这意味着一千个设备在一百万小时内。
或者一百万台设备。
最终失败或十亿设备，这大约是我们每小时有多少智能手机出现故障。
听起来是对的，我是说，如果你看着整个世界。
我想手机的故障率可能比，你知道每小时有不止一部手机掉线。
所以嗯，mtbf等于10亿乘1的5次方率。
这是相关的，因为计算机越来越多地进入我们的汽车。
所有这些关于你能力的规格都用适合率表示。
所以你会看到的。
尤其是做那种生意。
嗯，你会听到这个汽车安全完整性级别，定义了车辆中不同类别部件的不同配合率。
好啦，所以可靠性的设计原则如下。
所以当我们设计一个系统时，我们应该依赖于。
不能出现单点故障。
与之类比的是，通常来说，链条的强度取决于它最薄弱的环节。
有一个漂亮的。
这里所有amdahl定律的一个推论。
它总是帐篷里最长的杆子，会很突出的。
所以不管你知道，您可以不断提高一个组件的可靠性。
但最不可靠的人将占据主导地位。
嗯，所以我们通常要测量整个系统。
确保最不可靠的组件或最不可靠的组件足够可靠，好啦，所以我们要在这里快速休息一下。
然后我们要看看。
我们如何实际检测这些故障或故障，休息后见。
大家好，欢迎回到我们的可靠性模块，所以我们定义了度量可靠性的度量标准。
在此过程中，我们还定义了如何测量可靠性和可用性。
所以在尝试添加冗余之前，让我们首先弄清楚如何检测是否有错误，或者系统中的某种故障，我们需要对此做出反应。
所以让我们开始吧。
计算机系统中的错误可能发生在任何地方。
我是说我们可能会在真实的你身上犯错，我们的寄存器文件中可能有错误。
但很有可能是在记忆系统的某个地方，尤其是在公羊身上。
所以我们现在要做的是增加一点冗余。
一些多余的比特将使我们能够检测到。
记忆中的某个特定单词发生了错误。
所以我们要通过引入所谓的错误检测来做到这一点。
稍后更正代码。
所以你知道，为什么我们看到，为什么，为什么我们最有可能在内存中看到错误。
原因是我们有这么多的记忆细胞。
它们很小，所以当我们看DRAM定理时，本质上是在。
本质上，每一个比特都是一个微小的电容器储存一点点电荷。
如果储存在暗室中的电荷受到干扰。
我们可能认为我们在单元格中写入了一个零，但我们会读一个。
为什么会这样，它可能是由于电源中的扰动而发生的。
或者可能发生，因为一个粒子，呃。
以宇宙射线的形式，宇宙粒子的特定位置。
翻转钻头，基本上给电容器充足够的电。
为了改变对应于零的值。
对应于1的东西，这是一种特殊类型的错误，称为软错误。
真的没什么不对，身体上的记忆。
只是数据在里面的时候发生了错误。
所以当我们执行事情的时候，他们会工作得很好的。
与那些相反，有严重的错误。
位单元或内存中的一个字或整个芯片都可能失效。
这些就是所谓的硬失败或硬错误，嗯。
在那里，我们需要使用一种不同的冗余来修复它，我们可以修复里面的存储芯片。
那不在本课程的范围之内。
但你知道我们可以，嗯，更换有故障的芯片或有故障的芯片。
计算机系统中的这个驱动器，我们稍后会更多地讨论这个问题。
嗯，我们防止软错误的方法是使用所谓的错误检测。
和纠错码或简称edcs和ecccs，我们不能通过屏蔽我们的计算机系统来防御，不知何故，我的意思是，这些宇宙粒子中的一些可以穿过地球，所以你知道，我们通过其他方式保护我们的系统的可能性很低。
所以他们会打我们，不管我是什么意思，他们在打我们，他们在打我，就在我说话的时候，嗯，有可能他们会翻转一点，所以这里的想法是在我们的存储系统中添加一点冗余，告诉我们粒子撞击或供给扰动是否改变了某些比特。
所以这些多余的部分，与只是复制整个单词相反，呈现了很多，减去间接费用，更少的冗余保护，你知道的，把我们的，它的工作方式也是我们，在存储它们之前，先把我们的常规计算结果，我们操纵它们进入某种代码空间。
代码空间有冗余，所以如果错误指控将这个有效代码变成无效代码，我们可以检测到这一点，因为该代码字不存在于我们的代码集中，我说了很多关于，你知道的，很多关于假设的东西，让我们进入更实际的事情。
但在我们进入真正的实际例子之前，让我们首先介绍一些经常用于理解这些代码的重要内容，也就是所谓的汉明距离，它是以理查德·汉明的名字命名的，在贝尔实验室工作了很长时间的计算机先驱之一，后来转到学术界。
他在校正和探测方面做出了一些开创性的贡献。
他确实赢得了巡回演出奖。
汉明距离本质上是两个二进制数之间的位数差。
但当一点一点地看，你知道吗，这里有一个例子，我们打电话吧，假设我们有一个词p，另一个单词是Q，我们想知道它们在比特方面有多大的不同，所以p是0，1，0，1，q是0。
零一一一。
我们一点一点地比较，嗯，找出其中有多少是不同的，所以在最重要的一点上，它们都有零，下一个有效位是不同的，是1对0，所以到目前为止我们有一个距离，下一个比特是1。
我们只是嗯，你知道那是一样的，所以我们不必跟踪，单词p中的第四个有效位是零。
Q这个词是一个，所以汉明距离是2。
两个最低有效位都是，所以我们不增加这个汉明距离计数器。
所以单词p和q之间的距离是。
让我们再举一个例子，如果p和我们之前得到的一样。
零一零一和q有点不一样，一一零一。
P和Q井的区别是什么，让我们把它们和最重要的位位置进行比较。
我们有不同的距离，所以一个然后一样。
这个不同的一个对第三个位位置的零。
这个是一样的，第五位位置不一样，所以我们有三个。
最后一点是一样的，所以p和q之间的距离是3。
所以说，让我们看看当我们处理二进制数时，如何利用这一点，我们的计算结果只是二进制字，他们之间的汉明距离是一右，我们使用二进制表示，没有太多的冗余。
呃，因为我们想有效地使用我们的计算机硬件。
我们在这里要做的是不完全利用我们所有的存储，存储不同的二进制数，我们希望存储彼此有足够差异的码字，所以他们说有两个汉明距离，那么如果单词的汉明距离为2会发生什么呢，如果有一个比特错误。
我们从一个与我们的代码空间相对应的法律代码词开始，一个粒子一点点地撞击，一点点地翻转，所以这个新词，因为它与有效码字有一个距离，是无效的暗语，我们可以检测到我们有一个错误，让我们看一个实际的例子。
这很复杂，但是第一个实际的例子是一些非常常用的东西。
而且很简单，它在添加奇偶校验位，所以在我们的计算中，我们得到了一个二进制单词。
对于二进制单词的值。
在写入内存之前，我们添加一个奇偶校验位，所以我们以额外的位的形式添加了一个小标记。
这迫使存储在内存中的单词具有均匀的奇偶校验性。
嗯所以如果我们在工作，例如，在本例中有八个位的单词。
同样的事情也适用于三个两个位的单词。
我们怎样才能知道这个世界上有多少。
嗯，我们只要通过一个8输入的异或门。
异或门将产生我们的奇偶校验位，我们所做的，然后我们把这九个位，8位是我们的数据值和一个奇偶校验位。
把它们都储存在一起，在记忆中。
我们需要有更广泛的记忆，这就是为什么。
在一些昏暗的地方，我们有九个筹码。
其中一个来源，纯洁，好啦，当我们读到。
我们想检查一下我们的数据是否正确。
因此，我们将读取所有9位，并试图找出奇偶校验是否为偶数。
呃，我们怎样才能做好呢？
我们将再次通过一个门，这次和或门有八个输入。
我们将在输出端进行检查，支票，如果值为零。
然后在它的输入处有偶数个1。
所以这个词是有效的，如果是一个。
我们有一个错误，那么我们该怎么处理这个错误呢，嗯，这是画一个例外并让操作系统处理它的完美理由，有一件事你可以说服自己，我们稍后再讨论这个问题，因为我们储存的是，嗯，这里的冗余数字，我们可以说服自己。
在奇偶校验码的最小汉明距离内，我们必须有两个位的误差，为了从一个有效的代码字翻转到另一个有效的代码字，所以我们通过检查奇偶校验位来检测这个码字是无效的，现在我们检查错误的能力有限，对呀。
我们只能检查是否有一个位的错误，或者实际上有3位或5位的误差如果有奇数位的误差，如果我们有，如果我们同时翻转两个比特，我们不会发现的，但总的来说，只要一个奇偶校验位就足够了，因为你知道。
存储系统通常是这样设计的当被粒子撞击时，通常只有一个比特会翻转，下面是一个简单的例子，说明我们如何添加奇偶校验位。
所以我们从一个数据字开始，零一零一八位数据字，所以我们用X或门来检查这个词，我们发现我们已经有了偶数。
所以我们增加的奇偶校验位应该是零，所以我们加一个零，把这个9位的单词存储到内存中。
所以我们这里的等价是，即使你在这里有不同的数据工作。
零一零一零一，那个有五个一。
所以为了保持奇偶性。
即使我们要加一个1作为奇偶校验位，所以写在内存中的九位字。
现在会有偶数个。
当我们读到这个，让我们来看看我们存储在记忆中的第一个单词。
我们现在从记忆中读出它，如果我们用偶数个1来读它。
那么奇偶校验是均匀的。
所以没有错误，另一方面，如果有一点翻转，在这种情况下，在最有效的内存位位置中有一个位翻转。
我们数一数二。
三个，四五，因此，我们有一个x的奇偶校验输出。
或者是一个，有四个，有一个错误，在那一点上我们该怎么办。
我们。
你可能会问自己另一个快速的问题。
那么如果周边有错误会发生什么。
我们原词中的这八位都是正确的，最后一点是我们的奇偶校验位从零变成了一井。
我们仍然会检测到一个错误。
我们不知道错误在哪里，嗯，所以一次，在某种意义上，奇偶校验位受到保护。
但另一方面，你知道不会有任何差错，如果你没有一个对等的。
所以我们只能忍受，我们将讨论纠错。
稍作休息后，到时见。
大家好，欢迎回到我们的可靠性模块。
我们刚刚看到了如何引入奇偶校验位来检测。
本质上我们所做的，我们把汉明距离从一个增加到两个。
因此，我们可能的单词中有一半存储在记忆中。
嗯，是无效的。
所以如果我们读到一个无效的词，我们知道至少有一点错误。
我们不知道哪个是写进记忆中的正确单词。
因为2的距离不足以帮助我们进行校正。
简单地说，有多个单词离正确的单词只有一点远。
所以想出办法。
如何添加更多的冗余以执行纠错。
所以他提出了纠错码的概念，你需要的最小距离。
那是三的汉明距离，所以有一类代码基本上只做一次纠错。
双重错误检测，或者也被称为段代码汉明码是他实际上。
有趣的是他，发现他在所有的汽车上使用机械读卡器，在看他的穿孔卡片时经常出错，所以他把输入编码，这样他就不必处理连续的重读。
从概念上讲，这里是它的工作原理，假设我们有n位要编码。
因此有两个到n个可能的位模式，例如，假设我们有八个比特，因此可能会有256位的模式，所以你知道我们可以代表，你知道在这个空间里有256个可能的点，我们从这些单词中选择一个子集作为有价值的码字。
任何其他单词都是有错误的单词。
所以我们必须想出一些方法来检查文字的合法性。
然后我们会通过选择最近的法律代码词来执行纠错。
那个非法的暗语，嗯，你知道的。
我们在那里数，更短的错误模式更有可能，更长的误码模式，所以我们想回到最近的。
嗯，合法码字或有效码字。
所以如果我们有256个可能的暗语，我们从他们中挑八个。
嗯，一般来说，这是一个非常稀疏的模式。
如果有一点错误，我们基本上会回到最近的地方。
那个无效的暗语，这很可能是我们一开始写的词。
让我们看一个更有说明性的例子，在一个简单得多的案子上。
这是一个简单的案例，有8个暗语对应3位，它们被表示在一个立方体上，为了表明在那里你知道哪些实际上是相邻的，有一个汉明距离，而那些不相邻的。
会有一个大于1的距离。
所以如果你看看这些，嗯。
边缘，椅子和边缘，他们有汉明距离所以一个，如果他们有联系，他们有一个汉明距离，所以例如，零，零，零，和零，零一相距一点。
所以如果你想设计一个汉明距离为2的代码。
这使得我们可以检测到一点点错误，我们必须在这里选择一半可能的暗语。
所以我们会选择那些均等的，所以零，零，零一一。
零一，零一和零一。
请注意，我们基本上避免选择任何最近的邻居。
这是我们的奇偶校验码，所以这些暗语是无效的，但他们离最近的邻居只有一点距离，所以如果你看看这个暗语，零一零，我们不知道我们是否读到，我们不知道是哪一个，嗯，我们到底把哪个词。
是0 0 0 1还是1 1 0，三个人都有可能，所以为了做到这一点，我们需要一点时间来进行修正。
我们必须有更多的稀疏，或者在我们的代码中有更多的冗余。
所以我们需要少选一些词，所以如果我们把字数减少到四分之一。
我们可以选择在这个立方体相对边缘的两个。
所以这将是一个零零零和一一一。
所以我们有两个多余的位。
你知道的，我们只使用了八种可能模式中的两种。
就像我们在三个比特中使用两个多余的比特。
但现在如果有错误，如果我们读到这些片段中的任何一个，我们知道我们写到记忆中的最有可能的模式是什么，嗯，这些比特模式，零一零一零一，很可能是由零这个词引起的，因为他们有一个汉明距离，同样。
其他三个更接近于一个一个，因此，我们将通过执行纠错，我们会回到一对一，我们要看一个例子，我们怎么做，稍作休息后，再见啦，然后呢。
大家好，欢迎回到我们的可靠性模块，所以我们已经看到确实存在代码，不仅可以检测错误，但也能纠正。
但是我们展示的例子并不是一个非常实际的例子，因为它有很多开销。
为了编码有价值的一点信息，我们用了三个比特，所以我们有两百的开销，这里的诀窍和科学是如何设计这些代码，这样我们就可以用最小的开销获得所需的覆盖范围，这里所需的覆盖率就像单个错误检测。
一种具有双重错误检测的奇异纠错方法。
所以汉明也想出了这些密码，事情是这样的，我们将从我们计算的结果的数据位开始，我们将奇偶校验位与这些数据位交织在一起，形成我们要存储在内存中的暗语，在这种情况下，有一个特定的算法--如何将它们放在一起。
下面是在这个表上的交错是如何工作的，这里我们有将要存储在内存中的码字的位位置，一个，两个，三个，四，五个以此类推，在它下面编码的数据位位于特定的位置，一号在三号位置，D5已经就位，德二号在五号位置。
D3位于6号位置以此类推，这些其他位位置被奇偶校验位占据，P one，P二，P四，第八页，第16页，这是以一种特殊的方式完成的，使得奇偶校验位本质上总是对应于2的幂的位位置。
所以这些是二进制中对应于1-1-0的位位置，一个，零零，相对容易记住，但是在这个表格的底部，哪个数据位被哪个奇偶校验位覆盖，所以第一个奇偶校验位，Pone覆盖LSB等于1的所有职位。
所以所有奇数位都被第一个奇偶校验位覆盖，嗯，所以如果我们把P 1包括在那个位置，它也会覆盖自己，产生嗯，甚至奇偶性，所以基本上其他每一位都包括在第一个奇偶校验中，包括什么意思。
这些基本上是x或门中产生p 1的输入，最低有效位旁边的位等于1，所以这些基本上是对应于，你知道1，3，4等等，然后三个盖住四个的绳子以此类推，而且这种情况可以无限期地持续下去，但在实践中。
我们通常这样做一个街区，所以如果你有一个八位宽的数据字，我们将添加四个奇偶校验位来编码它，让我们来看看我们实际上是如何做到这一点的例子。
所以我们要生成这些奇偶校验位，为每个组创建均匀的奇偶校验。
假设我们想对一个字节的数据进行编码。
这个世界上有八位。
所以我们要创建一个编码词，通过把数据位放在它们应该在的地方。
然后我们把这些空间留给我们计算的奇偶校验位。
所以这些奇偶校验位应该放在它们合适的位位置。
所以先把第一部分，奇偶校验位进入位，位置一。
所以让我们来计算并通过这个例子，所以位置1将检查1-3位。
五个，七，九和十一。
所以我们要用黄色标记这些比特数一下有多少个。
一二，三四，因此，为了使均等。
奇偶校验位应该等于零。
位置二，它将检查2位对，三个。
有多少个。
有三个，因此为了使其均等，我们应该让这个问号等于1。
然后我们看一下四号位的检查，标记适当的位。
我们在黄色的碎片中只有一个。
因此，这也应该等于一，最后是八号位的检查，我们有参与文本的比特的最后一个，或者其中有两个，因此，这个问号应该等于零，好啦。
所以这是我们最后的代码，它由数据字和奇偶校验组成。
但让你知道。
不要看正确答案，让我们假设我们收到了一些东西，并想解码。
如果这个词正确，如果它不正确，我们喜欢纠正它，所以假设我们收到这个。
我们将把它映射到适当的位位置，我们会发现一点零。
前两位中的一位是奇偶校验位，这边还有一个，有一个奇偶校验位p 4，最后是一个奇偶校验位p 8，位8。
剩下的是数据位，让我们看看，如果这个词是正确的。
所以我们收到了这个，我们会很好地运行奇偶校验。
对于第一次奇偶校验，我们会找出你所知道的，奇偶校验位和该校验中对应的数据位。
数字是偶数，所以很好，它通过了第二个有这个。
P二，奇偶校验有一二三四五一。
所以不好，这是不正确的。
那个确实有错误。
然后我们要检查钻头，P四。
那张支票里有两张，所以这将是正确的，支票会没事的。
最后是p 8位错误。
因为它有三个1，然后有一个非常简单的方法，我们如何计算哪个位位置是误差。
你就可以算出代数，很简单，它非常优雅。
嗯它，这意味着位位置等于两个奇偶校验位之和。
第二和第八页，所以误差将在位位置10。
我们该怎么做才能解决这个问题，我们只要把不正确的部分翻过来。
把它变成零。
然后我们解码这个以确保它是正确的。
奇迹般地，所有的支票都满意了，我们已经很好地解码了正确的单词。
现在呢，如果我们必须处理具有，可能有不止一位的错误，所以如果你看看高端微处理器，他们通常使用代码，单次纠错，双重错误检测，但一些服务器处理器正在处理更有价值的工作，负载将有两个保护，以执行两位的校正。
所以有一种不同类型的汉明码叫做双重错误检测，三重错误检测，嗯还是口述，我们不打算深入讨论，嗯，你也知道，有很多关于这一点的参考资料，但通常当我们使用比微处理器更嘈杂的东西时。
比如通过WiFi发送数据或网络传输，以此类推，我们会看到更多的错误，这些错误通常是突发的，我们将看到如何增加冗余的不同方式，一般有，我们将要在那里遇到的事情，像循环误差，更正，像交错这样的事情。
打破这些模式，并用能够覆盖更少错误的代码攻击它们，但那是一种方式，超过本课程的内容，就是这样，这就是我们在这里要讨论的关于软错误的校正，这是我们在记忆中通常要做的事情，稍作休息后。
我们将看到对冗余的不同看法。
大家好，欢迎回到我们的模块可靠性，到目前为止，我们已经看到了如何添加位级冗余来避免软错误，某些瞬态效应引起的误差，像宇宙射线或环境中的扰动。
现在的问题是，当硬件出现永久故障时，我们该怎么办。
这个机制可能保护不了我们，并使用某种纠错来保护瞬态错误，有很高的开销，我们一般使用备件，嗯，在我们的硬件中，可以取代失败的部分，这种情况也发生在存储芯片中，但它深入到存储芯片的实际设计中。
所以对这门课来说是不够的。
但是有一个很好的例子，在这种驱动器的一种形式中。
所以这个驱动，传统上硬盘是机械设备。
他们确实倾向于失败，我们已经看到这些驱动器每年有一两个百分点的故障率。
呃，如今。
呃，这些驱动器上可能存储着有价值的数据。
一般情况下都有备份，但是把备份带回来的成本相当高。
嗯从到恢复驱动器故障后的操作。
所以一般来说，伯克利有个好主意。
作者：兰迪·卡茨和戴夫·帕特森。
在尝试提供冗余以帮助故障磁盘时。
这叫突袭，它代表廉价磁盘的冗余数组。
这个不贵。
在里面很合适，它适用于任何办公桌。
不管贵不贵。
这个想法实际上是作为一种替代方案部署的，而不是非常昂贵的。
高可靠性磁盘，可以用一系列相对便宜的磁盘替换。
现成光盘。
所以我们的数据就不会只存储在一个磁盘上，它将存储在多个磁盘上。
然后嗯，其中一件事。
所以说，存储阵列中通常使用的概念之一，文件是跨多个磁盘条带化的。
这是什么意思如果你有一个大文件。
而不是把所有东西都写到一个磁盘上，我们要把它分成几块。
并将其写入跨多个磁盘的条带，记住磁盘很慢。
所以如果我们能把文件并行地写入多个磁盘。
我们可以加快行动，所以这里的冗余可以用来加快磁盘操作。
但它也是为了防止，嗯，服务的减慢中断。
如果有失败。
所以它提高了我们的可用性，所以这还是会失败。
用户文件的内容仍将被重建，从数组中的剩余磁盘，当然有开销，我们没有使用所有的磁盘来存储不同用户的数据，我们正在使用一些磁盘作为冗余的来源，所以这就像，看看几种传统的方法如何看待这个多余的等级概念。
使用了一系列廉价的磁盘，有不同级别的速率零不提供任何冗余，不打算不打算谈论这个，它在那里只是为了加快速度，读一个是冗余的第一种形式，这个数组，所以本质上我们有两组磁盘，有多少就有多少，主磁盘。
就是这么多，嗯，我们有备份，这些被称为恢复组，基本上每一个磁盘，在最简单的情况下，我们这里只有一张磁盘，另一组中的一个将把数据从一个磁盘镜像到另一个磁盘，我们只有两份数据副本，这提供了冗余。
这里没有真正的速度权衡或利弊，我的意思是当这些不相等时就会发生一些轻微的权衡，当他们中的一个或一些比其他人慢的时候，或者他们可能在限制速度，但我们现在真的不需要深入讨论这个问题，这里的重点是。
我们需要的每一张磁盘都有100%的开销，我们提供一个额外的磁盘作为备份，但我们已经看到，我们真的不需要在，在DRAM纠错码中，那么，我们是否可以使用相同或相似的概念来在磁盘中提供冗余，所以我们当然有。
呃，这就是三的概念，我们在其中加上奇偶校验。
所以事情是这样的，我们可以有几个磁盘。
然后我们将在其中添加一个奇偶校验磁盘。
我们的数据将存储在这些磁盘中，你现在可以想象一下。
如你所知，单位数据，尽管这将在第三次突袭中以文字的形式被埋葬。
然后我们将在多个磁盘上对文件进行条带化。
所以我们要保存我们的数据，如果我们作为一个单独的位进行条带化。
更接近于突袭，但在射线3中我们可以想象这些是这些片段只是文字的代表。
然后我们将在一个单独的磁盘中提供奇偶校验，这里的差异度是用同样的方法计算的。
我们做得怎么样。
呃过去，如果我们有偶数。
世界上的比特，那么雪貂比特为零。
如果磁盘出现故障，然后奇偶校验将取代它，我们记得在拉姆，我们实际上不能那样做，我们的奇偶校验没有提供足够的信息来很好地知道错误来自哪里，这里实际上知道错误是从哪里来的，我们知道磁盘出了故障。
我们会得到一个额外的信息，即其中一个磁盘出现故障，我们知道哪个磁盘出了故障，所以这些奇偶校验位是用来恢复丢失的信息的，所以知道这个位为零，这个位是一，这个位是零，我们就知道丢失的位也是零。
所以那是射线3号突袭4号是它的变种，嗯。
它只是提供了更高的输入输出率。
所以这里是它的样子，这就是我们如何查看由五个磁盘组成的数组，所以有四个磁盘保存用户数据。
第五个圆盘保持奇偶校验，我们可以看到这些。
这些可能是增加逻辑磁盘地址，所以这些是不同的。
所以你可以把它看作是五个旋转的圆盘的内部。
较高的比率，I，O，那是什么意思呢？例如，你想做嗯，从磁盘零和这五个读取小文件，所以你知道，文件基本上可以放在一个磁盘里，所以我们基本上可以同时从零和五磁盘读取它们，同时，对于大磁盘，为了一个大的权利。
我们可以通过在所有的光盘上剥离来加快速度，它确实有一个，突袭4的挑战在于所有奇偶校验都驻留在一个磁盘上，所以如果你想写一堆小文件，那将是瓶颈，让我们快速看看，这是我们第五次突袭的灵感来源。
如果我们写两个小文件。
D0和D5，我们必须为每个。
现在的问题是我们如何生成奇偶校验。
嗯，为了生成奇偶校验，需要知道形成奇偶校验的所有其他数据。
所以我们需要阅读所有其他的，这个，所以也许你可以继续读它们。
然后重新填充奇偶校验。
或者相反，这通常是实际正在做的，在空中管制员那里。
嗯，奇偶校验盘有旧和，所以我们也许可以在你的阅读中重新计算奇偶性，用此数据更新并写回，这里是直线性代数，无论哪种情况，这里的瓶颈是八点五，所有的奇偶校验都被写到这个磁盘上。
所以我们可能需要读取奇偶校验数据，更新它，写回来，同时处理多个文件，所以一般来说，磁盘将是，突袭5的动机，Raid Five是提高吞吐量和保持奇偶校验的一种方法。
它的实现方式是通过简单地将奇偶校验分布在，在整个数组中交错奇偶校验，所以现在奇偶校验不仅仅是在我们的第五次驱动中，它将遍布所有部落，所以如果我们写到这里的D0和D5磁盘，会写在这两个独立的磁盘上。
我们可以同时做到这一点，因为它们的奇偶校验与3号和4号磁盘相关联，我们能做到的，我们也可以同时进行，简而言之，突袭，还有其他不同类型的突袭，通常使用更多的几个，一些额外的磁盘。
但我们不打算在这门课中讨论它们，总之，我们已经看到了冗余是如何提高我们的可靠性的，嗯，我们可以通过使用空间冗余来利用这一点，通过使用额外的硬件，以额外比特形式出现的额外硬件，额外支票，如果操作失败。
通过重复操作来冗余，我们第一次看到可用性和可用性的定义，我们已经看到了一个具体的例子，我们如何使用奇偶校验进行单个错误检测，然后我们看到了如何使用汉明密码，距离三到，加上一个比特，执行双重错误检测。
然后我们已经看到raarray是处理失败驱动器的方法，这是一个例子，额外的硬件如何，额外的光盘冗余提高了系统的可用性，如果磁盘驱动器出现故障，我们的系统不会崩溃，它的性能其实是，系统性能得到提高。
它不会因使用多个驱动器而降级，我们已经看到有不同的贸易水平，外面有更多的人，在实践中，无论如何，我们对它们是如何工作的有了合理的很好的了解，就是这样，这就是您想要涵盖的关于可靠性的所有内容。
这就结束了这个模块。
