WEBVTT

00:00.120 --> 00:00.960
Istruttore: In questa

00:00.960 --> 00:03.000
lezione parleremo della memoria ECC, nota come

00:03.000 --> 00:05.040
codice di correzione degli errori.

00:05.040 --> 00:06.720
Ma prima dobbiamo affrontare

00:06.720 --> 00:10.020
il concetto di non-parità e parità in termini di memoria.

00:10.020 --> 00:12.000
Quando si parla di non-parità, si tratta di

00:12.000 --> 00:14.160
una memoria che è solo una memoria standard.

00:14.160 --> 00:16.200
Non controlla la presenza di errori

00:16.200 --> 00:18.870
e permette di inserire o togliere dati

00:18.870 --> 00:21.390
dalla memoria a piacimento.

00:21.390 --> 00:23.910
La memoria non paritaria è molto economica da produrre

00:23.910 --> 00:26.970
e ha una velocità superiore a quella della memoria paritaria.

00:26.970 --> 00:28.800
La memoria di parità, invece, viene utilizzata

00:28.800 --> 00:31.110
per eseguire il controllo degli errori di base e per

00:31.110 --> 00:32.610
garantire l'affidabilità e l'integrità

00:32.610 --> 00:34.890
del contenuto della memoria.

00:34.890 --> 00:35.910
Per questo motivo,

00:35.910 --> 00:38.460
questa memoria sarà più lenta di quella non

00:38.460 --> 00:40.440
paritaria, ma ha l'affidabilità

00:40.440 --> 00:42.000
necessaria per i server e per

00:42.000 --> 00:44.910
alcune workstation desktop di fascia alta.

00:44.910 --> 00:47.220
Le memorie che dispongono di un controllo di parità

00:47.220 --> 00:49.320
sono in grado di eseguire un calcolo di base

00:49.320 --> 00:50.490
sulla base di ciò che vedono

00:50.490 --> 00:52.920
per verificare se i dati sono buoni o meno.

00:52.920 --> 00:55.110
E se i dati sono buoni, li utilizzerà.

00:55.110 --> 00:57.240
In caso contrario, si verificherà un errore, ma non

00:57.240 --> 00:58.560
sarà possibile risolverlo.

00:58.560 --> 01:00.750
Sarà in grado di dire che c'è un errore,

01:00.750 --> 01:02.460
ma non so come risolverlo.

01:02.460 --> 01:04.860
In pratica, ogni byte ha un

01:04.860 --> 01:07.230
bit di parità associato.

01:07.230 --> 01:10.230
Quindi, invece di avere otto bit, si hanno nove

01:10.230 --> 01:13.860
bit, perché otto bit di dati più un bit per la parità.

01:13.860 --> 01:16.200
Ora il bit di parità verrà impostato al momento giusto.

01:16.200 --> 01:17.970
Poi, quando si legge dalla memoria, viene

01:17.970 --> 01:19.830
calcolato e confrontato per determinare

01:19.830 --> 01:21.420
se qualche bit è cambiato dall'ultima

01:21.420 --> 01:24.330
volta che i dati sono stati scritti nella memoria.

01:24.330 --> 01:25.470
Questo tipo di controllo

01:25.470 --> 01:28.470
si limita però a rilevare gli errori di un singolo bit.

01:28.470 --> 01:30.300
E se ci sono due bit alterati, il

01:30.300 --> 01:32.310
controllo di parità può passare,

01:32.310 --> 01:35.550
perché ricordate, i bit possono essere solo 0 o 1.

01:35.550 --> 01:39.683
Ad esempio, supponiamo di aver memorizzato

01:39.683 --> 01:44.460
il numero 0, che in binario si scrive 00000000.

01:44.460 --> 01:47.700
Ora, se sommo tutti questi bit, ottengo otto

01:47.700 --> 01:50.400
0 che mi danno 0 come bit di parità.

01:50.400 --> 01:52.560
Ora, se vado a leggere quel numero dalla

01:52.560 --> 01:54.090
memoria e vedo che ci sono otto

01:54.090 --> 01:56.220
0, li sommo e ottengo 0, lo 0 corrisponde

01:56.220 --> 01:58.050
al mio bit di parità come 0, quindi

01:58.050 --> 01:59.850
sono dati buoni.

01:59.850 --> 02:00.720
Supponiamo

02:00.720 --> 02:02.430
invece che io stia

02:02.430 --> 02:07.200
scrivendo il numero 1 che si scrive 00000001.

02:07.200 --> 02:10.470
Ora se sommo tutti questi numeri, otterrò 1.

02:10.470 --> 02:13.530
E lo inserirò nel mio bit di parità del nono bit.

02:13.530 --> 02:15.720
Così facendo, ora leggo da lì e

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

02:19.560 --> 02:21.210
Ma se lo metto in memoria

02:21.210 --> 02:22.410
e rimane lì per

02:22.410 --> 02:24.060
un paio d'ore e quell'1

02:24.060 --> 02:25.440
è stato cambiato

02:25.440 --> 02:27.240
in uno 0 per sbaglio, se

02:27.240 --> 02:29.910
lo leggo ora e ottengo 00000000,

02:29.910 --> 02:31.170
lo sommo e ottengo

02:31.170 --> 02:34.830
0, e lo confronto con il mio bit di parità che

02:34.830 --> 02:42.510
aveva un 1, questo mi dice che c'è un errore e che qualcosa è andato storto.

02:42.510 --> 02:44.730
Non so quali di questi otto bit siano stati modificati,

02:44.730 --> 02:46.560
ma almeno uno di essi lo è stato.

02:46.560 --> 02:47.580
D'altra parte,

02:47.580 --> 02:48.413
se il numero

02:48.413 --> 02:52.260
da 00000001 è stato modificato in qualcosa

02:52.260 --> 02:57.210
come 01010001, ora ho due bit che sono stati cambiati

02:57.210 --> 02:58.950
da 0 a 1 per errore dalla

02:58.950 --> 03:01.590
memoria.

03:01.590 --> 03:04.260
Quando guardo la mia parità, sarà ancora un 1 perché

03:04.260 --> 03:06.930
quando li sommo, se è un numero dispari, sarà un

03:06.930 --> 03:08.940
1 per il mio bit di parità.

03:08.940 --> 03:10.770
E se li sommo e il risultato è un numero pari,

03:10.770 --> 03:12.090
il risultato sarà uno 0.

03:12.090 --> 03:13.500
Quindi, come si può vedere,

03:13.500 --> 03:14.940
non sarà possibile rilevare

03:14.940 --> 03:17.340
un errore se due bit sono stati cambiati all'interno

03:17.340 --> 03:20.100
di questo, se si utilizza un calcolo di parità.

03:20.100 --> 03:23.490
Ora, la buona notizia è che circa il 90% della maggior parte degli

03:23.490 --> 03:25.770
errori sarà di tipo singolo e quindi il controllo

03:25.770 --> 03:28.080
di parità può essere sufficiente per la maggior

03:28.080 --> 03:30.000
parte delle situazioni.

03:30.000 --> 03:31.530
Ma se si ha a che fare con qualcosa come la

03:31.530 --> 03:33.360
gestione di server per una banca, avere qualsiasi

03:33.360 --> 03:35.520
tipo di errore potrebbe essere una cosa negativa.

03:35.520 --> 03:37.890
Quindi vogliamo qualcosa di meglio della

03:37.890 --> 03:40.650
parità ed è qui che entra in gioco l'ECC.

03:40.650 --> 03:43.830
ECC è l'acronimo di Error Correcting Code (codice di correzione degli errori).

03:43.830 --> 03:45.930
Un codice a correzione di errore è il tipo di memoria

03:45.930 --> 03:48.390
che porta la parità al livello successivo.

03:48.390 --> 03:50.460
Ora non solo è in grado di rilevare la presenza

03:50.460 --> 03:51.810
di un errore, proprio come

03:51.810 --> 03:54.780
la parità, ma può anche correggere l'errore.

03:54.780 --> 03:57.300
L'ECC è un po' più lento della parità, che

03:57.300 --> 03:59.490
è anche più lento della non parità.

03:59.490 --> 04:00.990
Quindi si rinuncia a un po' di

04:00.990 --> 04:02.610
prestazioni per questa capacità

04:02.610 --> 04:04.290
aggiuntiva, ma si ottiene una maggiore

04:04.290 --> 04:06.300
integrità e affidabilità della memoria

04:06.300 --> 04:07.950
quando si usa l'ECC, perché sarà

04:07.950 --> 04:11.760
in grado di rilevare gli errori e di correggerli.

04:11.760 --> 04:14.040
In generale, il codice ECC o di correzione

04:14.040 --> 04:15.570
degli errori viene utilizzato

04:15.570 --> 04:18.660
solo nelle workstation o nei server di fascia alta, a causa

04:18.660 --> 04:20.190
del costo aggiuntivo e dell'elevato

04:20.190 --> 04:22.500
livello di integrità necessario solo in

04:22.500 --> 04:25.230
questo tipo di ambienti.

04:25.230 --> 04:26.340
Ora vi starete chiedendo:

04:26.340 --> 04:28.980
come fa l'ECC a determinare cosa c'è di sbagliato

04:28.980 --> 04:30.990
e come risolverlo?

04:30.990 --> 04:32.040
Per farlo, utilizzerà

04:32.040 --> 04:33.960
qualcosa noto come memoria tamponata

04:33.960 --> 04:35.700
o registrata.

04:35.700 --> 04:37.980
Ora la memoria tamponata o registrata

04:37.980 --> 04:39.570
ha un hardware aggiuntivo che

04:39.570 --> 04:42.870
si interpone tra la memoria e la CPU o il processore.

04:42.870 --> 04:44.850
Questo hardware è chiamato registro

04:44.850 --> 04:46.290
e memorizza i dati in un buffer

04:46.290 --> 04:48.720
prima di inviarli alla CPU.

04:48.720 --> 04:50.760
Questa funzione è utilizzata come misura di affidabilità

04:50.760 --> 04:51.990
in molti sistemi, in particolare

04:51.990 --> 04:53.550
in sistemi come i server che hanno molti

04:53.550 --> 04:55.380
moduli di memoria diversi in cui possono verificarsi

04:55.380 --> 04:56.910
errori.

04:56.910 --> 04:59.730
Questi sistemi richiedono il buffering o la registrazione dei dati

04:59.730 --> 05:01.350
per ridurre il carico elettrico utilizzato

05:01.350 --> 05:02.370
da questi sistemi che hanno

05:02.370 --> 05:04.680
grandi quantità di moduli di memoria, e questo può essere

05:04.680 --> 05:06.450
abbinato alla memoria di parità o di codice

05:06.450 --> 05:08.220
di correzione degli errori per essere in

05:08.220 --> 05:10.140
grado di fornire l'affidabilità aggiuntiva

05:10.140 --> 05:13.020
che si sta cercando e rilevare gli errori.

05:13.020 --> 05:15.510
Ora, per utilizzare i moduli di codice a correzione

05:15.510 --> 05:18.840
di errore, la scheda madre deve supportarli così come la CPU.

05:18.840 --> 05:21.450
Se uno dei due componenti non supporta l'ECC, anche

05:21.450 --> 05:24.450
se si acquistano i moduli ECC, che costano di più, non si

05:24.450 --> 05:27.150
otterranno i vantaggi ECC aggiuntivi.

05:27.150 --> 05:28.800
Quindi, tenetelo a mente.

05:28.800 --> 05:32.700
Inoltre, la maggior parte delle schede madri supporta o meno l'ECC.

05:32.700 --> 05:34.140
In genere non è un'opzione.

05:34.140 --> 05:36.690
Pertanto, se si acquista una scheda madre che supporta

05:36.690 --> 05:38.940
l'ECC, è necessario acquistare moduli ECC,

05:38.940 --> 05:41.490
ovvero moduli di memoria registrati.

05:41.490 --> 05:44.160
Se si trova una scheda madre che supporta moduli

05:44.160 --> 05:46.170
ECC o non ECC, in genere non li supporta

05:46.170 --> 05:49.110
entrambi contemporaneamente.

05:49.110 --> 05:51.570
Quindi tutti i moduli devono essere ECC

05:51.570 --> 05:53.880
o nessuno dei moduli può essere ECC.

05:53.880 --> 05:56.700
Una miscela di questi elementi può causare errori nel sistema

05:56.700 --> 05:58.950
e la scheda madre non sa come gestirli.

05:58.950 --> 06:00.210
L'ultima cosa che vorrei

06:00.210 --> 06:02.370
menzionare è che se state usando le DDR5,

06:02.370 --> 06:04.710
queste ultime hanno un controllo degli errori

06:04.710 --> 06:06.780
interno ai moduli stessi.

06:06.780 --> 06:10.500
Questo non è considerato ECC o un modulo ECC.

06:10.500 --> 06:11.850
La correzione degli errori all'interno

06:11.850 --> 06:14.520
dei moduli DDR5 più recenti può essere utilizzata anche su

06:14.520 --> 06:17.160
schede madri che non supportano l'ECC, mantenendo una certa

06:17.160 --> 06:19.710
capacità di controllo degli errori.

06:19.710 --> 06:21.420
Si tratta di una forma diversa di controllo degli

06:21.420 --> 06:23.910
errori e non è considerata codice a correzione di errore.

06:23.910 --> 06:26.250
Tenetelo presente e non lasciatevi confondere

06:26.250 --> 06:27.810
quando siete sul campo.

06:27.810 --> 06:29.640
Si tratta di una forma diversa di controllo

06:29.640 --> 06:32.040
degli errori e i moduli DDR5 possono ancora essere

06:32.040 --> 06:34.740
venduti come moduli ECC o non ECC, perché oltre al controllo

06:34.740 --> 06:37.290
degli errori interno, possono anche lavorare con

06:37.290 --> 06:39.840
la CPU e la scheda madre se supportano l'ECC e ora

06:39.840 --> 06:41.580
sono anche codici di correzione

06:41.580 --> 06:44.040
degli errori.

06:44.040 --> 06:45.510
So che questo crea un po' di confusione.

06:45.510 --> 06:48.210
Quindi, fate attenzione a questo aspetto quando siete sul campo.