Instrutor: Nesta
lição, falaremos sobre a memória ECC, conhecida
como código de correção de erros.
Mas, primeiro, precisamos abordar
o conceito de não-paridade e paridade em termos de memória.
Agora, quando falamos de não-paridade, essa
é uma memória que é apenas uma memória padrão.
Ele não verifica se há erros e permite que
os dados sejam colocados ou retirados da memória à vontade,
e é isso que a maioria das memórias será.
A fabricação da memória não paritária é muito barata
e sua velocidade é maior do que a da memória paritária.
A memória de paridade, por outro lado, será
usada para realizar a verificação básica de erros
e garantir que o conteúdo da memória
seja confiável e tenha integridade.
Por esse motivo, essa
memória será mais lenta do que a memória não-paritária,
mas tem a confiabilidade necessária para
servidores e determinadas estações
de trabalho de desktop de ponta.
Agora, a memória que tem uma verificação de paridade
será capaz de fazer um cálculo básico com base
no que está vendo para verificar
se os dados são bons ou não.
E se esses dados forem bons, ele os utilizará.
E se não for, ocorrerá um erro, mas não será
possível corrigi-lo.
Ele só poderá dizer que há um erro aqui,
mas não sei como corrigi-lo.
Basicamente, isso funciona pelo fato de cada
byte ter um bit de paridade associado a ele.
Portanto, em vez de ter oito bits, agora você tem nove
bits, porque oito bits de dados mais um bit para paridade.
Agora, esse bit de paridade será definido no momento certo.
Em seguida, ele será calculado e comparado
quando você ler da memória para determinar
se algum dos bits foi alterado desde
a última vez que os dados foram gravados na memória.
No entanto, esse tipo de
verificação se limita a detectar esses erros de bit único.
E se houver dois bits que foram alterados,
a verificação de paridade poderá ser aprovada,
pois lembre-se de que os bits só podem ser 0 ou 1.
Por exemplo, digamos que eu tenha armazenado
o número 0, que é escrito como 00000000 em binário.
Agora, se eu somar todos esses bits, obtenho oito
0s, o que me dá 0 como bit de paridade.
Agora, se eu for ler esse número da memória
e vir que há oito 0s, eu os somo
e obtenho 0, 0 corresponde ao meu bit
de paridade como 0, portanto, esses
dados são bons.
Agora, por outro
lado, digamos que eu estivesse
escrevendo o número 1, que é escrito como 00000001.
Agora, se eu somar todos esses números, vou obter 1.
E colocarei isso em minha parte de paridade da nona parte.
Ao fazer isso, agora leio a partir daí
e recebo 00000001.
Mas se eu colocasse isso
na memória e ficasse
lá por algumas horas e
esse 1 fosse alterado
para 0 por acidente, se
eu lesse agora e obtivesse 00000000, somasse esses
dados e obtivesse 0 e comparasse com meu bit de
paridade, que tinha um 1, isso me diria que houve um erro
e que algo deu errado.
Não sei quais desses oito bits foram alterados,
mas pelo menos um deles foi.
Por outro lado,
se esse número
de 00000001 fosse alterado para algo como 01010001,
eu teria agora dois bits que foram alterados de 0s para 1 por acidente pela memória.
Quando olho para a minha paridade, ela ainda será
1 porque, quando eu as somar, se for um número ímpar,
será 1 para o meu bit de paridade.
E se eu somar esses valores e for um
número par, será um 0.
Portanto, como você pode ver,
não será possível detectar um
erro se dois bits forem alterados dentro disso se
você estiver usando um cálculo de tipo de paridade.
Agora, a boa notícia é que cerca de 90% da maioria dos erros serão
do tipo de bit único e, portanto, a verificação
de paridade geralmente é suficiente para
a maioria das situações.
Mas se você estiver lidando com algo
como a execução de servidores para um banco,
ter qualquer tipo de erro pode ser algo ruim.
Portanto, queremos algo melhor do que
a paridade, e é aí que o ECC entra em ação.
Agora, ECC significa Error Correcting Code (código de correção de erros).
Um código de correção de erros é o tipo de memória
que eleva a paridade ao próximo nível.
Agora, além de detectar a existência de
um erro, assim como a paridade,
ele também pode corrigir esse erro para você.
Agora, o ECC é um pouco mais lento do que a paridade, que
também é mais lenta do que a não-paridade.
Portanto, você está abrindo
mão de um pouco de desempenho em
troca desse recurso extra, mas
está obtendo maior integridade e confiabilidade
da memória ao usar o ECC, pois ele
será capaz de detectar e corrigir esses
erros.
Em geral, você só verá o ECC ou o código de correção
de erros sendo usado em estações
de trabalho ou servidores realmente sofisticados devido
ao custo adicional, e esse alto
nível extra de integridade só é necessário
nesses tipos de ambientes.
Agora você deve estar
se perguntando: como o ECC realmente determina o que
estava errado e como corrigi-lo?
Bem, para fazer isso, ele
usará algo conhecido como memória armazenada
em buffer ou registrada.
Agora, a memória com buffer ou memória registrada
tem um hardware adicional que
fica entre a memória e a CPU ou o processador.
Esse hardware é chamado de registro
e armazena dados em um buffer
antes de serem enviados à CPU.
Esse recurso é usado como medida de confiabilidade
em muitos sistemas, especialmente
em sistemas como servidores que têm
muitos módulos de memória diferentes onde
podem ocorrer erros.
Esses sistemas exigem o armazenamento em buffer ou o registro
dos dados para reduzir a carga elétrica
usada por esses sistemas
que têm grandes quantidades de módulos de memória,
e isso pode ser combinado com paridade ou
memória de código de correção de erros para
oferecer a confiabilidade adicional que
você está procurando e detectar esses erros.
Agora, para usar os módulos de código de correção de
erros, a placa-mãe deve ser compatível com eles, assim como a CPU.
Se um desses componentes não for compatível
com ECC, mesmo que você compre os módulos ECC, que custam
mais, não terá o benefício extra do ECC.
Portanto, tenha isso em mente.
Além disso, a maioria das placas-mãe é compatível com ECC ou não.
Geralmente, essa não é uma opção.
Portanto, se você comprar uma placa-mãe que suporte
ECC, terá que comprar módulos ECC, que são
os módulos de memória registrados.
Agora, se você encontrar uma placa-mãe que suporte
módulos ECC ou não ECC, geralmente
ela não suportará ambos ao mesmo tempo.
Portanto, todos os seus módulos precisam
ser ECC ou nenhum deles pode ser ECC.
Ter uma mistura deles pode causar erros no sistema e a
placa-mãe não saberá como lidar com isso.
Agora, a última coisa que
quero mencionar é que, se você estiver usando
DDR5, a DDR5 tem alguma verificação de erros
interna nos próprios módulos.
Isso não é considerado ECC ou um módulo ECC.
Portanto, essa correção de
erros dentro dos módulos DDR5 mais novos pode ser usada
em placas-mãe que não suportam ECC e você ainda terá
algum recurso de verificação de erros.
Essa é uma forma diferente de verificação
de erros e não é considerada um código de correção de erros.
Portanto, tenha isso em mente e não deixe que isso o confunda
quando estiver em campo.
Essa é uma forma diferente de verificação
de erros e os módulos DDR5 ainda podem ser vendidos
como módulos ECC ou não ECC, pois, além dessa verificação
interna de erros, eles também podem trabalhar
com a CPU e a placa-mãe se elas suportarem ECC e
agora também são códigos de correção
de erros.
Sei que isso pode ser um pouco confuso.
Portanto, fique atento a isso quando estiver em campo.