WEBVTT

00:00.120 --> 00:00.960
Instructor: En esta

00:00.960 --> 00:03.000
lección, vamos a hablar de la memoria ECC, conocida

00:03.000 --> 00:05.040
como código de corrección de errores.

00:05.040 --> 00:06.720
Pero antes, debemos tratar el

00:06.720 --> 00:10.020
concepto de no paridad y paridad en términos de memoria.

00:10.020 --> 00:12.000
Cuando hablamos de no-paridad,

00:12.000 --> 00:14.160
se trata de memoria estándar.

00:14.160 --> 00:16.200
No comprueba si hay errores y permite

00:16.200 --> 00:18.870
meter o sacar datos de la memoria a voluntad y esto

00:18.870 --> 00:21.390
es lo que va a ser la mayoría de la memoria.

00:21.390 --> 00:23.910
La memoria no paritaria es muy barata de fabricar

00:23.910 --> 00:26.970
y tiene mayor velocidad que la paritaria.

00:26.970 --> 00:28.800
Por otro lado, la memoria de paridad se va

00:28.800 --> 00:31.110
a utilizar para realizar una comprobación básica de

00:31.110 --> 00:32.610
errores y garantizar que el contenido

00:32.610 --> 00:34.890
de la memoria es fiable y tiene integridad.

00:34.890 --> 00:35.910
Por este motivo, esta

00:35.910 --> 00:38.460
memoria va a ser más lenta que las memorias no paritarias,

00:38.460 --> 00:40.440
pero tiene la fiabilidad necesaria para

00:40.440 --> 00:42.000
los servidores y determinadas

00:42.000 --> 00:44.910
estaciones de trabajo de sobremesa de gama alta.

00:44.910 --> 00:47.220
Ahora la memoria que tiene una comprobación de paridad

00:47.220 --> 00:49.320
va a ser capaz de hacer un cálculo básico basado

00:49.320 --> 00:50.490
en lo que está viendo para

00:50.490 --> 00:52.920
verificar si los datos son buenos o no.

00:52.920 --> 00:55.110
Y si esos datos son buenos, los utilizará.

00:55.110 --> 00:57.240
Y si no lo es, se producirá un error pero no

00:57.240 --> 00:58.560
podrá solucionarlo.

00:58.560 --> 01:00.750
Sólo podrá decir hay un error aquí pero

01:00.750 --> 01:02.460
no sé cómo solucionarlo.

01:02.460 --> 01:04.860
Básicamente, esto funciona haciendo que cada

01:04.860 --> 01:07.230
byte tenga asociado un bit de paridad.

01:07.230 --> 01:10.230
Así que en lugar de tener ocho bits, ahora tienes nueve

01:10.230 --> 01:13.860
bits porque ocho bits de datos más un bit para la paridad.

01:13.860 --> 01:16.200
Ahora que el bit de paridad se va a establecer en el momento adecuado.

01:16.200 --> 01:17.970
Y entonces, va a ser calculado y comparado

01:17.970 --> 01:19.830
cuando leas de la memoria para determinar si

01:19.830 --> 01:21.420
alguno de los bits ha cambiado desde

01:21.420 --> 01:24.330
que esos datos fueron escritos por última vez en esa memoria.

01:24.330 --> 01:25.470
Sin embargo, este tipo

01:25.470 --> 01:28.470
de comprobación se limita a detectar errores de un solo bit.

01:28.470 --> 01:30.300
Y si hay dos bits que han sido alterados,

01:30.300 --> 01:32.310
esa comprobación de paridad puede pasar,

01:32.310 --> 01:35.550
porque recuerda, los bits sólo pueden ser un 0 o un 1.

01:35.550 --> 01:38.850
Así, por ejemplo, supongamos que he

01:38.850 --> 01:39.683
almacenado

01:39.683 --> 01:44.460
el número 0, que se escribe 00000000 en binario.

01:44.460 --> 01:47.700
Ahora, si sumo todos esos bits, obtengo ocho 0,

01:47.700 --> 01:50.400
lo que me da 0 para mi bit de paridad.

01:50.400 --> 01:52.560
Ahora si voy a leer ese número de la memoria

01:52.560 --> 01:54.090
y veo que hay ocho 0s, los sumo

01:54.090 --> 01:56.220
y obtengo 0, 0 coincide con mi bit de

01:56.220 --> 01:58.050
paridad como 0, por lo que son datos

01:58.050 --> 01:59.850
buenos.

01:59.850 --> 02:00.720
Por otro lado,

02:00.720 --> 02:02.430
supongamos que escribo

02:02.430 --> 02:07.200
el número 1, que se escribe 00000001.

02:07.200 --> 02:10.470
Ahora, si sumo todos esos números, obtendré 1.

02:10.470 --> 02:13.530
Y pondré eso en mi parte de paridad de la novena parte.

02:13.530 --> 02:15.720
Al hacer esto, ahora leo de eso y

02:15.720 --> 02:17.133
obtengo 00000001.

02:19.560 --> 02:21.210
Pero si pongo eso en

02:21.210 --> 02:22.410
la memoria y se

02:22.410 --> 02:24.060
sentó allí durante

02:24.060 --> 02:25.440
un par de horas y que

02:25.440 --> 02:27.240
1 se cambió a un 0 por accidente,

02:27.240 --> 02:31.170
si leo que ahora y me sale 00000000, y los sumo,

02:31.170 --> 02:34.830
me sale 0, y lo comparo con mi bit de paridad

02:34.830 --> 02:39.210
que tenía un 1 en ella, que ahora me dice que hay un error

02:39.210 --> 02:42.510
y algo salió mal.

02:42.510 --> 02:44.730
No sé cuál de esos ocho bits se cambió,

02:44.730 --> 02:46.560
pero al menos uno de ellos sí.

02:46.560 --> 02:47.580
Ahora, por

02:47.580 --> 02:48.413
otro lado,

02:48.413 --> 02:52.260
si ese número de 00000001 se cambió a algo

02:52.260 --> 02:57.210
como 01010001, ahora tenía dos bits que fueron cambiados

02:57.210 --> 02:58.950
de 0s a 1 por accidente

02:58.950 --> 03:01.590
por la memoria.

03:01.590 --> 03:04.260
Cuando miro a mi paridad, todavía va a ser un 1 porque

03:04.260 --> 03:06.930
cuando estoy sumando esos, si es un número impar,

03:06.930 --> 03:08.940
va a ser un 1 para mi bit de paridad.

03:08.940 --> 03:10.770
Y si los sumo y es un número

03:10.770 --> 03:12.090
par, será un 0.

03:12.090 --> 03:13.500
Así que como puedes ver, no

03:13.500 --> 03:14.940
vas a ser capaz de detectar un

03:14.940 --> 03:17.340
error si dos bits fueron cambiados dentro de

03:17.340 --> 03:20.100
esto si estás usando un cálculo de tipo paridad.

03:20.100 --> 03:23.490
La buena noticia es que el 90% de los errores son de un

03:23.490 --> 03:25.770
solo bit, por lo que la comprobación

03:25.770 --> 03:28.080
de paridad suele ser suficiente en

03:28.080 --> 03:30.000
la mayoría de los casos.

03:30.000 --> 03:31.530
Pero si se trata de algo como ejecutar

03:31.530 --> 03:33.360
servidores para un banco, tener cualquier

03:33.360 --> 03:35.520
tipo de errores puede ser algo malo.

03:35.520 --> 03:37.890
Así que queremos algo mejor que la paridad

03:37.890 --> 03:40.650
y ahí es donde entra en juego ECC.

03:40.650 --> 03:43.830
Ahora ECC significa Código de Corrección de Errores.

03:43.830 --> 03:45.930
Un código de corrección de errores es el tipo

03:45.930 --> 03:48.390
de memoria que lleva la paridad al siguiente nivel.

03:48.390 --> 03:50.460
Ahora no sólo puede detectar que hay un error,

03:50.460 --> 03:51.810
al igual que la paridad, sino

03:51.810 --> 03:54.780
que también puede corregir ese error por ti.

03:54.780 --> 03:57.300
ECC es un poco más lento que la paridad, que también

03:57.300 --> 03:59.490
es más lenta que la no paridad.

03:59.490 --> 04:00.990
Por lo tanto, se renuncia a algo

04:00.990 --> 04:02.610
de rendimiento a cambio de esta

04:02.610 --> 04:04.290
capacidad adicional, pero se obtiene

04:04.290 --> 04:06.300
una mayor integridad y fiabilidad de

04:06.300 --> 04:07.950
la memoria cuando se utiliza ECC,

04:07.950 --> 04:09.900
ya que es capaz de detectar y corregir

04:09.900 --> 04:11.760
los errores.

04:11.760 --> 04:14.040
En general, el ECC o código de corrección

04:14.040 --> 04:15.570
de errores sólo se utiliza

04:15.570 --> 04:18.660
en estaciones de trabajo o servidores de gama muy alta,

04:18.660 --> 04:20.190
ya que su coste adicional y

04:20.190 --> 04:22.500
ese nivel extra de integridad sólo son

04:22.500 --> 04:25.230
necesarios en ese tipo de entornos.

04:25.230 --> 04:26.340
Ahora te estarás preguntando,

04:26.340 --> 04:28.980
¿cómo determina realmente el ECC qué estaba mal

04:28.980 --> 04:30.990
y cómo solucionarlo?

04:30.990 --> 04:32.040
Bueno, para hacer eso,

04:32.040 --> 04:33.960
va a utilizar algo conocido como memoria

04:33.960 --> 04:35.700
intermedia o registrada.

04:35.700 --> 04:37.980
La memoria intermedia o memoria registrada

04:37.980 --> 04:39.570
tiene un hardware adicional

04:39.570 --> 04:42.870
que se sitúa entre la memoria y la CPU o el procesador.

04:42.870 --> 04:44.850
Este hardware se denomina registro

04:44.850 --> 04:46.290
y almacena datos en un búfer

04:46.290 --> 04:48.720
antes de enviarlos a la CPU.

04:48.720 --> 04:50.760
Esta característica se utiliza como medida de fiabilidad

04:50.760 --> 04:51.990
en muchos sistemas, especialmente

04:51.990 --> 04:53.550
en sistemas como servidores que tienen muchos

04:53.550 --> 04:55.380
módulos de memoria diferentes en los que pueden

04:55.380 --> 04:56.910
producirse errores.

04:56.910 --> 04:59.730
Estos sistemas requieren el almacenamiento en búfer o el registro de

04:59.730 --> 05:01.350
los datos con el fin de reducir la carga eléctrica

05:01.350 --> 05:02.370
utilizada por estos sistemas

05:02.370 --> 05:04.680
que tienen grandes cantidades de módulos de memoria, y esto

05:04.680 --> 05:06.450
puede ser emparejado con la paridad o la memoria

05:06.450 --> 05:08.220
de código de corrección de errores para ser

05:08.220 --> 05:10.140
capaz de darle esa fiabilidad adicional que usted

05:10.140 --> 05:13.020
está buscando y detectar esos errores.

05:13.020 --> 05:15.510
Ahora bien, para poder utilizar módulos de código de corrección

05:15.510 --> 05:18.840
de errores, la placa base debe ser compatible con ellos, al igual que la CPU.

05:18.840 --> 05:21.450
Si alguno de esos componentes no admite ECC,

05:21.450 --> 05:24.450
aunque compres los módulos ECC, que cuestan más, no

05:24.450 --> 05:27.150
obtendrás esa ventaja adicional de ECC.

05:27.150 --> 05:28.800
Así que tenlo en cuenta.

05:28.800 --> 05:32.700
Además, la mayoría de las placas base admiten ECC o no.

05:32.700 --> 05:34.140
Generalmente no es una opción.

05:34.140 --> 05:36.690
Así que si compras una placa base que admita ECC,

05:36.690 --> 05:38.940
tendrás que comprar módulos ECC, que son

05:38.940 --> 05:41.490
esos módulos de memoria registrados.

05:41.490 --> 05:44.160
Ahora bien, si encuentras una placa base que

05:44.160 --> 05:46.170
admita módulos ECC o no ECC, generalmente

05:46.170 --> 05:49.110
no admitirán ambos al mismo tiempo.

05:49.110 --> 05:51.570
Así que todos tus módulos tienen que ser ECC

05:51.570 --> 05:53.880
o ninguno de tus módulos puede ser ECC.

05:53.880 --> 05:56.700
Tener una mezcla de ellos puede causar errores en el sistema

05:56.700 --> 05:58.950
y la placa base no sabrá cómo manejarlo.

05:58.950 --> 06:00.210
La última cosa que quiero

06:00.210 --> 06:02.370
mencionar es que si estás usando DDR5,

06:02.370 --> 06:04.710
DDR5 tiene alguna comprobación de errores

06:04.710 --> 06:06.780
interna en los propios módulos.

06:06.780 --> 06:10.500
No se considera ECC ni módulo ECC.

06:10.500 --> 06:11.850
Por tanto, esta corrección

06:11.850 --> 06:14.520
de errores de los nuevos módulos DDR5 se puede utilizar

06:14.520 --> 06:17.160
en placas base que no admitan ECC y seguir contando con

06:17.160 --> 06:19.710
cierta capacidad de comprobación de errores.

06:19.710 --> 06:21.420
Se trata de una forma diferente de comprobación

06:21.420 --> 06:23.910
de errores y no se considera código de corrección de errores.

06:23.910 --> 06:26.250
Así que tenlo en cuenta y no dejes que eso te confunda

06:26.250 --> 06:27.810
cuando estés en el campo.

06:27.810 --> 06:29.640
Se trata de una forma distinta de comprobación

06:29.640 --> 06:32.040
de errores y los módulos DDR5 aún pueden venderse

06:32.040 --> 06:34.740
como módulos ECC o no ECC, porque además de esa comprobación

06:34.740 --> 06:37.290
de errores interna, también pueden funcionar

06:37.290 --> 06:41.580
con la CPU y la placa base si admiten ECC y ahora también tienen código de corrección

06:41.580 --> 06:44.040
de errores.

06:44.040 --> 06:45.510
Sé que es un poco confuso.

06:45.510 --> 06:48.210
Así que tenlo en cuenta cuando salgas al campo.