WEBVTT

00:00.120 --> 00:00.960
Instructeur : Dans cette

00:00.960 --> 00:03.000
leçon, nous allons parler de la mémoire ECC, connue

00:03.000 --> 00:05.040
sous le nom de code correcteur d'erreurs.

00:05.040 --> 00:06.720
Mais tout d'abord, nous devons aborder

00:06.720 --> 00:10.020
les concepts de non-parité et de parité en termes de mémoire.

00:10.020 --> 00:12.000
Lorsque nous parlons de non-parité, il s'agit

00:12.000 --> 00:14.160
d'une mémoire qui n'est qu'une mémoire standard.

00:14.160 --> 00:16.200
Elle ne vérifie pas les erreurs et permet

00:16.200 --> 00:18.870
d'entrer ou de sortir des données de la mémoire à volonté,

00:18.870 --> 00:21.390
ce qui est le cas de la plupart des mémoires.

00:21.390 --> 00:23.910
La mémoire sans parité est très bon marché à fabriquer

00:23.910 --> 00:26.970
et sa vitesse est plus élevée que celle de la mémoire avec parité.

00:26.970 --> 00:28.800
La mémoire de parité, quant à elle, sera

00:28.800 --> 00:31.110
utilisée pour effectuer un contrôle d'erreur de

00:31.110 --> 00:32.610
base et pour garantir la fiabilité

00:32.610 --> 00:34.890
et l'intégrité du contenu de la mémoire.

00:34.890 --> 00:35.910
Pour cette raison,

00:35.910 --> 00:38.460
cette mémoire sera plus lente que la mémoire non

00:38.460 --> 00:40.440
paritaire, mais elle offre la fiabilité

00:40.440 --> 00:42.000
nécessaire aux serveurs et à

00:42.000 --> 00:44.910
certaines stations de travail haut de gamme.

00:44.910 --> 00:47.220
La mémoire qui dispose d'un contrôle de parité

00:47.220 --> 00:49.320
va pouvoir effectuer un calcul de base sur la

00:49.320 --> 00:50.490
base de ce qu'elle voit pour

00:50.490 --> 00:52.920
vérifier si les données sont bonnes ou non.

00:52.920 --> 00:55.110
Et si ces données sont bonnes, il les utilisera.

00:55.110 --> 00:57.240
Si ce n'est pas le cas, une erreur se produira, mais il ne

00:57.240 --> 00:58.560
sera pas possible de la corriger.

00:58.560 --> 01:00.750
Il pourra simplement dire qu'il y a une erreur mais

01:00.750 --> 01:02.460
que je ne sais pas comment la corriger.

01:02.460 --> 01:04.860
Fondamentalement, cela fonctionne en associant

01:04.860 --> 01:07.230
à chaque octet un bit de parité.

01:07.230 --> 01:10.230
Ainsi, au lieu d'avoir huit bits, vous avez maintenant

01:10.230 --> 01:13.860
neuf bits car huit bits de données plus un bit pour la parité.

01:13.860 --> 01:16.200
Le bit de parité sera alors placé au bon moment.

01:16.200 --> 01:17.970
Ensuite, ces données seront calculées et comparées

01:17.970 --> 01:19.830
lors de la lecture de la mémoire afin de déterminer

01:19.830 --> 01:21.420
si l'un des bits a changé depuis la dernière

01:21.420 --> 01:24.330
fois que ces données ont été écrites dans la mémoire.

01:24.330 --> 01:25.470
Ce type de contrôle se limite

01:25.470 --> 01:28.470
toutefois à la détection des erreurs d'un seul bit.

01:28.470 --> 01:30.300
Et si deux bits ont été modifiés,

01:30.300 --> 01:32.310
le contrôle de parité peut passer,

01:32.310 --> 01:35.550
car les bits ne peuvent être que des 0 ou des 1.

01:35.550 --> 01:38.850
Par exemple, supposons que je stocke

01:38.850 --> 01:39.683
le nombre

01:39.683 --> 01:44.460
0, qui s'écrit 00000000 en binaire.

01:44.460 --> 01:47.700
Si j'additionne tous ces bits, j'obtiens huit

01:47.700 --> 01:50.400
0, ce qui me donne 0 comme bit de parité.

01:50.400 --> 01:52.560
Maintenant, si je lis ce nombre dans la mémoire

01:52.560 --> 01:54.090
et que je vois qu'il y a huit 0, je

01:54.090 --> 01:56.220
les additionne et j'obtiens 0. Le 0 correspond

01:56.220 --> 01:58.050
à mon bit de parité qui est 0, donc ce sont

01:58.050 --> 01:59.850
des données correctes.

01:59.850 --> 02:00.720
En revanche,

02:00.720 --> 02:02.430
imaginons que j'écrive

02:02.430 --> 02:07.200
le chiffre 1, qui s'écrit 00000001.

02:07.200 --> 02:10.470
Si j'additionne tous ces chiffres, j'obtiens 1.

02:10.470 --> 02:13.530
Je le mettrai dans mon bit de parité du neuvième bit.

02:13.530 --> 02:15.720
En faisant cela, je lis maintenant à partir de

02:15.720 --> 02:17.133
cela et j'obtiens 00000001.

02:19.560 --> 02:21.210
Mais si j'ai mis ces données

02:21.210 --> 02:22.410
en mémoire, qu'elles

02:22.410 --> 02:24.060
y sont restées pendant quelques

02:24.060 --> 02:25.440
heures et que ce 1 s'est

02:25.440 --> 02:27.240
transformé en 0 par accident,

02:27.240 --> 02:29.910
si je les lis maintenant et que j'obtiens 00000000,

02:29.910 --> 02:31.170
et que j'additionne ces

02:31.170 --> 02:34.830
données, j'obtiens 0, et que je les compare à mon bit de parité

02:34.830 --> 02:39.210
qui contenait un 1, cela m'indique maintenant qu'il y a une erreur et que quelque

02:39.210 --> 02:42.510
chose n'a pas fonctionné.

02:42.510 --> 02:44.730
Je ne sais pas lequel de ces huit bits a été modifié,

02:44.730 --> 02:46.560
mais au moins l'un d'entre eux l'a été.

02:46.560 --> 02:47.580
D'un autre côté,

02:47.580 --> 02:48.413
si ce nombre

02:48.413 --> 02:52.260
de 00000001 a été modifié en quelque chose comme

02:52.260 --> 02:57.210
01010001, j'ai maintenant deux bits qui ont été modifiés

02:57.210 --> 02:58.950
de 0 à 1 par accident par

02:58.950 --> 03:01.590
la mémoire.

03:01.590 --> 03:04.260
Lorsque je regarde ma parité, ce sera toujours un 1 parce que

03:04.260 --> 03:06.930
lorsque j'additionne les chiffres, si c'est un nombre impair,

03:06.930 --> 03:08.940
ce sera un 1 pour mon bit de parité.

03:08.940 --> 03:10.770
Et si je les additionne et que le résultat est

03:10.770 --> 03:12.090
un nombre pair, ce sera un 0.

03:12.090 --> 03:13.500
Comme vous pouvez le constater,

03:13.500 --> 03:14.940
vous ne pourrez pas détecter une

03:14.940 --> 03:17.340
erreur si deux bits ont été changés à l'intérieur de

03:17.340 --> 03:20.100
cette zone si vous utilisez un calcul de type parité.

03:20.100 --> 03:23.490
La bonne nouvelle, c'est qu'environ 90 % de la plupart des

03:23.490 --> 03:25.770
erreurs sont des erreurs d'un seul bit et

03:25.770 --> 03:28.080
que le contrôle de parité est donc suffisant

03:28.080 --> 03:30.000
dans la plupart des cas.

03:30.000 --> 03:31.530
Mais s'il s'agit de faire fonctionner

03:31.530 --> 03:33.360
les serveurs d'une banque, toute

03:33.360 --> 03:35.520
erreur peut être néfaste.

03:35.520 --> 03:37.890
Nous voulons donc quelque chose de mieux

03:37.890 --> 03:40.650
que la parité et c'est là que l'ECC entre en jeu.

03:40.650 --> 03:43.830
ECC est l'abréviation de Error Correcting Code (code de correction d'erreur).

03:43.830 --> 03:45.930
Un code correcteur d'erreur est le type de

03:45.930 --> 03:48.390
mémoire qui porte la parité au niveau supérieur.

03:48.390 --> 03:50.460
Il peut non seulement détecter une erreur,

03:50.460 --> 03:51.810
comme le fait la parité,

03:51.810 --> 03:54.780
mais aussi corriger cette erreur pour vous.

03:54.780 --> 03:57.300
L'ECC est un peu plus lent que la parité, qui est également

03:57.300 --> 03:59.490
plus lente que la non-parité.

03:59.490 --> 04:00.990
Vous renoncez donc à certaines performances

04:00.990 --> 04:02.610
pour cette capacité supplémentaire,

04:02.610 --> 04:04.290
mais vous bénéficiez d'une intégrité

04:04.290 --> 04:06.300
et d'une fiabilité accrues de votre mémoire lorsque

04:06.300 --> 04:07.950
vous utilisez la technologie ECC, car

04:07.950 --> 04:09.900
elle sera en mesure de détecter ces erreurs et

04:09.900 --> 04:11.760
de les corriger.

04:11.760 --> 04:14.040
En général, l'ECC (code correcteur d'erreurs)

04:14.040 --> 04:15.570
n'est utilisé que dans les stations

04:15.570 --> 04:18.660
de travail ou les serveurs haut de gamme, en raison du coût supplémentaire

04:18.660 --> 04:20.190
et du fait que ce niveau élevé

04:20.190 --> 04:22.500
d'intégrité n'est nécessaire que dans ce type

04:22.500 --> 04:25.230
d'environnement.

04:25.230 --> 04:26.340
Vous vous demandez peut-être

04:26.340 --> 04:28.980
maintenant comment l'ECC détermine ce qui n'allait

04:28.980 --> 04:30.990
pas et comment le réparer ?

04:30.990 --> 04:32.040
Pour ce faire, il va utiliser

04:32.040 --> 04:33.960
ce que l'on appelle la mémoire tampon ou

04:33.960 --> 04:35.700
la mémoire enregistrée.

04:35.700 --> 04:37.980
La mémoire tampon ou mémoire enregistrée dispose

04:37.980 --> 04:39.570
d'un matériel supplémentaire

04:39.570 --> 04:42.870
qui s'interpose entre la mémoire et le processeur.

04:42.870 --> 04:44.850
Ce matériel, appelé registre, stocke les données

04:44.850 --> 04:46.290
dans une mémoire tampon avant qu'elles

04:46.290 --> 04:48.720
ne soient envoyées à l'unité centrale.

04:48.720 --> 04:50.760
Cette fonction est utilisée comme mesure de fiabilité dans

04:50.760 --> 04:51.990
de nombreux systèmes, en particulier

04:51.990 --> 04:53.550
les systèmes tels que les serveurs qui comportent

04:53.550 --> 04:55.380
un grand nombre de modules de mémoire différents où des

04:55.380 --> 04:56.910
erreurs peuvent se produire.

04:56.910 --> 04:59.730
Ces systèmes nécessitent la mise en mémoire tampon ou l'enregistrement

04:59.730 --> 05:01.350
des données afin de réduire la charge électrique

05:01.350 --> 05:02.370
utilisée par ces systèmes

05:02.370 --> 05:04.680
qui ont de grandes quantités de modules de mémoire, et

05:04.680 --> 05:06.450
cela peut être associé à la parité ou à la mémoire

05:06.450 --> 05:08.220
de code correcteur d'erreurs pour vous donner

05:08.220 --> 05:10.140
la fiabilité supplémentaire que vous recherchez

05:10.140 --> 05:13.020
et détecter ces erreurs.

05:13.020 --> 05:15.510
Pour pouvoir utiliser des modules de code correcteur d'erreurs,

05:15.510 --> 05:18.840
votre carte mère doit les prendre en charge, tout comme votre processeur.

05:18.840 --> 05:21.450
Si l'un ou l'autre de ces composants ne prend pas en charge l'ECC,

05:21.450 --> 05:24.450
même si vous achetez des modules ECC qui coûtent plus cher, vous ne bénéficierez

05:24.450 --> 05:27.150
pas de l'avantage supplémentaire de l'ECC.

05:27.150 --> 05:28.800
Il faut donc garder cela à l'esprit.

05:28.800 --> 05:32.700
En outre, la plupart des cartes mères prennent en charge ou non la technologie ECC.

05:32.700 --> 05:34.140
Ce n'est généralement pas une option.

05:34.140 --> 05:36.690
Par conséquent, si vous achetez une carte mère qui prend

05:36.690 --> 05:38.940
en charge l'ECC, vous devrez acheter des modules ECC,

05:38.940 --> 05:41.490
c'est-à-dire des modules de mémoire enregistrés.

05:41.490 --> 05:44.160
Si vous trouvez une carte mère qui prend en charge

05:44.160 --> 05:46.170
les modules ECC ou non ECC, elle ne prend

05:46.170 --> 05:49.110
généralement pas en charge les deux en même temps.

05:49.110 --> 05:51.570
Ainsi, tous vos modules doivent être ECC ou

05:51.570 --> 05:53.880
aucun de vos modules ne peut être ECC.

05:53.880 --> 05:56.700
La présence d'un mélange de ces éléments peut provoquer des erreurs dans

05:56.700 --> 05:58.950
le système et la carte mère ne saura pas comment les gérer.

05:58.950 --> 06:00.210
La dernière chose que je voudrais

06:00.210 --> 06:02.370
mentionner, c'est que si vous utilisez des DDR5,

06:02.370 --> 06:04.710
ces derniers disposent d'un système de contrôle d'erreur

06:04.710 --> 06:06.780
interne aux modules eux-mêmes.

06:06.780 --> 06:10.500
Il ne s'agit pas d'un ECC ou d'un module ECC.

06:10.500 --> 06:11.850
Cette correction d'erreur dans

06:11.850 --> 06:14.520
les nouveaux modules DDR5 peut donc être utilisée sur des cartes

06:14.520 --> 06:17.160
mères qui ne prennent pas en charge l'ECC et vous aurez toujours

06:17.160 --> 06:19.710
une certaine capacité de contrôle d'erreur.

06:19.710 --> 06:21.420
Il s'agit d'une forme différente de contrôle d'erreur,

06:21.420 --> 06:23.910
qui n'est pas considérée comme un code correcteur d'erreur.

06:23.910 --> 06:26.250
Gardez donc cela à l'esprit et ne vous laissez pas désorienter

06:26.250 --> 06:27.810
lorsque vous êtes sur le terrain.

06:27.810 --> 06:29.640
Il s'agit d'une forme différente de contrôle

06:29.640 --> 06:32.040
des erreurs et les modules DDR5 peuvent toujours être

06:32.040 --> 06:34.740
vendus en tant que modules ECC ou non ECC, parce qu'en plus de

06:34.740 --> 06:37.290
ce contrôle interne des erreurs, ils peuvent également

06:37.290 --> 06:39.840
fonctionner avec le CPU et la carte mère s'ils prennent en

06:39.840 --> 06:41.580
charge l'ECC et ils sont maintenant également

06:41.580 --> 06:44.040
des codes correcteurs d'erreurs.

06:44.040 --> 06:45.510
Je sais que cela peut prêter à confusion.

06:45.510 --> 06:48.210
Il faut donc en être conscient lorsque l'on est sur le terrain.