WEBVTT

00:00.120 --> 00:00.960
教师：在这节课中,

00:00.960 --> 00:05.040
我们将讨论ECC内存, 即所谓的纠错码｡

00:05.040 --> 00:10.020
但首先, 我们需要涵盖非奇偶校验和奇偶校验的概念｡

00:10.020 --> 00:12.000
当我们谈到非奇偶校验时,

00:12.000 --> 00:14.160
这是一个标准内存｡

00:14.160 --> 00:16.200
它不检查错误, 它允许数据随意放入或取出内存,

00:16.200 --> 00:21.390
这就是大多数内存的情况｡

00:21.390 --> 00:23.910
非奇偶校验存储器的制造成本非常低,

00:23.910 --> 00:26.970
并且它的速度比奇偶校验存储器更高｡

00:26.970 --> 00:31.110
另一方面, 奇偶校验存储器将用于执行基本的错误检查,

00:31.110 --> 00:34.890
并确保存储器内容的可靠性和完整性｡

00:34.890 --> 00:35.910
正因为如此,

00:35.910 --> 00:38.460
这种内存会比非奇偶校验内存慢,

00:38.460 --> 00:44.910
但它具有服务器和某些高端桌面工作站所需的可靠性｡

00:44.910 --> 00:50.490
现在, 具有奇偶校验的内存将能够根据它所看到的内容进行基本计算,

00:50.490 --> 00:52.920
以验证数据是否正确｡

00:52.920 --> 00:55.110
如果这些数据是好的, 它会使用它｡ 

00:55.110 --> 00:57.240
如果不是, 就会出现错误,

00:57.240 --> 00:58.560
但无法修复｡

00:58.560 --> 01:02.460
它只能说这里有一个错误, 但我不知道如何修复它｡

01:02.460 --> 01:07.230
基本上, 它的工作原理是让每个字节都有一个与之关联的奇偶校验位｡

01:07.230 --> 01:13.860
因此, 不再是8位, 而是9位, 因为8个数据位加上1个奇偶校验位｡

01:13.860 --> 01:16.200
现在, 奇偶校验位将在正确的时间设置｡ 

01:16.200 --> 01:17.970
然后, 当你从内存中读取数据时,

01:17.970 --> 01:21.420
它会被计算和比较, 以确定自上次将数据写入内存以来,

01:21.420 --> 01:24.330
是否有任何位发生了变化｡

01:24.330 --> 01:28.470
但是, 这种类型的检查仅限于检测这些单个位错误｡

01:28.470 --> 01:30.300
如果有两个比特被修改了,

01:30.300 --> 01:32.310
奇偶校验可能会通过, 因为记住,

01:32.310 --> 01:35.550
比特只能是0或1｡

01:35.550 --> 01:38.850
例如, 假设我存储了数字0,

01:38.850 --> 01:44.460
它在二进制中被写为0000000｡

01:44.460 --> 01:47.700
现在, 如果我把所有这些位加在一起, 我得到8个0,

01:47.700 --> 01:50.400
这给了我0作为奇偶校验位｡

01:50.400 --> 01:52.560
现在如果我从内存中读取这个数字,

01:52.560 --> 01:54.090
我看到有八个0, 我把它们加在一起,

01:54.090 --> 01:59.850
我得到0, 0匹配我的奇偶校验位, 所以这是好的数据｡

01:59.850 --> 02:00.720
另一方面,

02:00.720 --> 02:02.430
假设我写下数字1,

02:02.430 --> 02:07.200
它被写成00000001｡

02:07.200 --> 02:10.470
如果我把这些数字加起来, 我会得到1｡ 

02:10.470 --> 02:13.530
我把它放在第九位的奇偶校验位里｡ 

02:13.530 --> 02:17.133
通过这样做, 我现在从那里读取, 我得到00000001｡

02:19.560 --> 02:21.210
因为所有这些加起来都是1,

02:21.210 --> 02:22.410
并且与我的奇偶校验位相匹配,

02:22.410 --> 02:27.240
我知道数据是好的, 但是如果我把它放入内存中, 它在那里呆了几个小时,

02:27.240 --> 02:31.170
1意外地变成了0, 如果我现在读到它, 我得到0000000,

02:31.170 --> 02:34.830
我把它们加在一起, 我得到0, 我把它与我的奇偶校验位进行比较,

02:34.830 --> 02:42.510
其中有一个1, 现在告诉我有一个错误, 出了问题｡

02:42.510 --> 02:44.730
我不知道这八个比特中的哪一个被改变了,

02:44.730 --> 02:46.560
但至少有一个被改变了｡

02:46.560 --> 02:48.413
现在, 另一方面,

02:48.413 --> 02:52.260
如果从00000001的数字被改变为01010001,

02:52.260 --> 03:01.590
我现在有两个比特被内存从0意外地改变为1｡

03:01.590 --> 03:04.260
当我看我的奇偶校验时, 它仍然是1, 因为当我把这些加起来时,

03:04.260 --> 03:08.940
如果它是奇数, 它将是我的奇偶校验位的1｡

03:08.940 --> 03:10.770
如果我把它们加起来是偶数,

03:10.770 --> 03:12.090
那就是0｡

03:12.090 --> 03:14.940
如你所见, 如果你使用奇偶校验类型的计算,

03:14.940 --> 03:20.100
你将无法检测到错误, 如果这里面有两个比特被改变｡

03:20.100 --> 03:23.490
现在, 好消息是大约90%的错误都是单比特类型的错误,

03:23.490 --> 03:30.000
因此奇偶校验通常足以满足我们的大多数情况｡

03:30.000 --> 03:31.530
但是, 如果您正在处理像为银行运行服务器这样的事情,

03:31.530 --> 03:35.520
出现任何类型的错误都可能是一件坏事｡

03:35.520 --> 03:37.890
所以我们想要比平价更好的东西,

03:37.890 --> 03:40.650
这就是ECC发挥作用的地方｡

03:40.650 --> 03:43.830
ECC是Error Correcting Code的缩写｡ 

03:43.830 --> 03:48.390
纠错码是将奇偶校验提升到下一个级别的存储器类型｡

03:48.390 --> 03:50.460
现在它不仅可以检测到错误,

03:50.460 --> 03:51.810
就像奇偶校验一样,

03:51.810 --> 03:54.780
而且还可以为您纠正错误｡

03:54.780 --> 03:59.490
现在ECC比奇偶校验慢一点, 奇偶校验也比非奇偶校验慢｡

03:59.490 --> 04:02.610
因此, 您会为这个额外的功能放弃一些性能,

04:02.610 --> 04:04.290
但当您使用ECC时,

04:04.290 --> 04:11.760
您会从内存中获得更高的完整性和可靠性, 因为它将能够检测到这些错误并修复这些错误｡

04:11.760 --> 04:18.660
一般来说, 你只会看到ECC或纠错码被用于真正的高端工作站或服务器,

04:18.660 --> 04:25.230
因为额外的成本和额外的高水平的完整性只需要在这些类型的环境｡

04:25.230 --> 04:26.340
现在你可能想知道,

04:26.340 --> 04:30.990
ECC实际上是如何确定错误的, 以及如何修复它的？

04:30.990 --> 04:32.040
要做到这一点,

04:32.040 --> 04:35.700
它将使用缓冲内存或注册内存｡

04:35.700 --> 04:37.980
现在缓冲内存或注册内存有额外的硬件,

04:37.980 --> 04:42.870
它将位于内存和CPU或处理器之间｡

04:42.870 --> 04:48.720
这个硬件被称为寄存器, 它在数据被发送到CPU之前将数据存储到缓冲区｡

04:48.720 --> 04:50.760
此功能在许多系统中用作可靠性度量,

04:50.760 --> 04:56.910
特别是像服务器这样具有许多不同内存模块的系统, 其中可能发生错误｡

04:56.910 --> 05:02.370
这些系统需要缓冲或注册数据, 以减少这些具有大量内存模块的系统所使用的电气负载,

05:02.370 --> 05:13.020
并且这可以与奇偶校验或纠错码内存配对, 以便能够为您提供您正在寻找的额外可靠性并检测这些错误｡

05:13.020 --> 05:15.510
现在, 为了使用纠错码模块,

05:15.510 --> 05:18.840
您的主板必须支持它以及您的CPU｡

05:18.840 --> 05:24.450
如果这些组件不支持ECC, 那么即使您购买了成本更高的ECC模块,

05:24.450 --> 05:27.150
您也不会获得额外的ECC优势｡

05:27.150 --> 05:28.800
所以记住这一点｡ 

05:28.800 --> 05:32.700
大多数主板要么支持ECC, 要么不支持｡ 

05:32.700 --> 05:34.140
一般来说这不是一个选择｡ 

05:34.140 --> 05:36.690
因此, 如果您购买支持ECC的主板,

05:36.690 --> 05:38.940
您将不得不购买ECC模块,

05:38.940 --> 05:41.490
即那些注册的内存模块｡

05:41.490 --> 05:46.170
现在, 如果您找到支持ECC或非ECC模块的主板,

05:46.170 --> 05:49.110
通常它们不会同时支持两者｡

05:49.110 --> 05:53.880
因此, 您的所有模块都必须是ECC, 否则您的所有模块都不能是ECC｡

05:53.880 --> 05:56.700
混合使用它们会导致系统错误,

05:56.700 --> 05:58.950
主板不知道如何处理｡

05:58.950 --> 06:00.210
现在我想提的最后一件事是,

06:00.210 --> 06:06.780
如果你使用的是DDR5, DDR5在模块本身内部确实有一些错误检查｡

06:06.780 --> 06:10.500
这不被认为是ECC或ECC模块｡ 

06:10.500 --> 06:14.520
因此, 新的DDR5模块中的这种错误校正可以在不支持ECC的主板上使用,

06:14.520 --> 06:19.710
并且仍然具有一些错误检查功能｡

06:19.710 --> 06:21.420
这是一种不同形式的错误检查,

06:21.420 --> 06:23.910
它不被认为是纠错码｡

06:23.910 --> 06:26.250
所以请记住这一点, 不要让它混淆你,

06:26.250 --> 06:27.810
当你在外地｡

06:27.810 --> 06:29.640
这是一种不同形式的错误检查,

06:29.640 --> 06:32.040
DDR5模块仍然可以作为ECC或非ECC模块出售,

06:32.040 --> 06:44.040
因为除了内部错误检查之外, 如果它们支持ECC, 它们还可以与CPU和主板一起工作, 并且它们现在也是错误纠正代码｡

06:44.040 --> 06:45.510
我知道这有点让人困惑｡ 

06:45.510 --> 06:48.210
所以你出外勤的时候要注意这点｡