Erros de memória, saiba como corrigir.

     Todos os chips de memória estão sujeitos a erros. A probabilidade da ocorrência de erros é muito pequena, mas dependendo da aplicação, o erro pode ser tolerado ou não. Se um computador usado exclusivamente para jogos apresentar um erro por ano, isto não causará problema algum. Se um computador usado no monitoramento de um reator nuclear, a taxa de um erro a cada 10 anos seria catastrófica. Existem mecanismos para detectar erros, e outros que permitem ainda corrigir o erro encontrado. 

     Partimos do princípio de que, quando um erro ocorre em uma célula, este erro está em apenas um bit. A chance de ocorrerem dois erros simultâneos na mesma célula de memória é praticamente nula. Entretanto são usados códigos sofisticados que permitem detectar (mas não corrigir) erros em dois bits simultâneos. O funcionamento desses códigos é muito complexo, por isso mostraremos aqui como resolver o problema mais comum: detectar e corrigir erros do tipo single bit, ou seja, quando ocorrem em um único bit dentro de uma célula de memória. O método mais empregado é o chamado código de Hamming. Vamos apresentar um método mais simples, bastante parecido com o código de Hamming. Podemos chama-lo de método de Laercius – que obviamente não é usado na prática, e tem apenas fins explicativos. Ele não detecta erros em dois bits simultâneos, mas é de simples entendimento.  Este método consiste em adicionar para cada dado, um grupo de bits de checagem. Quanto mais bits de dados, mais bits de checagem devem ser usados. A tabela abaixo mostra para dados de 8, 16, 32 e 64 bits, quantos bits devem ser usados para checagem:

     Mostraremos o funcionamento da correção de erros pelo código de Laercius usando dados de 8 bits, por ser mais fácil de entender. O funcionamento para 64 bits é semelhante, mas didaticamente é mais fácil explicar como funciona para 8 bits. Para o grupo de 8 bits são adicionados 5 bits de checagem. Note que na prática não é feita esta checagem para apenas 8 bits, pois adicionando 5 bits, estamos quase dobrando o custo da memória. Para grupos de 64 bits, usados nos PCs modernos, bastam 8 bits para fazer a detecção e correção de erros, totalizando 72 bits, um aumento bastante viável que não afeta muito o custo das memórias.

     A figura mostra um dado de 8 bits, representado por b7b6b5b4b3b2b1b0. Os 5 bits de controle são p1, p2, p4, pd e pp. Esses 5 bits são calculados da seguinte forma:
     p1: Paridade calculada entre b5, b7, b3 e b1
     p2: Paridade calculada entre b4, b6, b2 e b0
     p4: Paridade calculada entre b5, b7, b4 e b6
     pd: Paridade calculada entre b7, b6, b5, b4, b3, b2, b1, b0
     pp: Paridade calculada entre p1, p2, p4 e pd.
     Quando é feita uma gravação na memória, são gerados e armazenados os 5 bits de checagem. Quando é feita uma leitura, são lidos os dados e os bits de checagem. Em função dos dados lidos, os bits de checagem são novamente calculados. São comparados os bits de checagem armazenados com os calculados. Se forem iguais, está tudo correto. Se existirem diferenças, temos um erro na memória.
     É recalculada a paridade dos dados pd. Também é recalculada a paridade dos bits de controle, pp. Se pd estiver correta, não existe erro nos 8 bits de dados da memória. Se pd indicar erro, então existe um bit errado, ou entre os 8 bits de dados, ou então o erro pode ser o próprio bit pd. Entrará então em jogo o bit de paridade pp. Se estiver errado, significa que existe um bit errado, que será necessariamente pd. Isto significa que os 8 bits de dados estão corretos. Se pp estiver correto, significa que os bits p1, p2, p4 e pd estão corretos, então o erro está em um dos 8 bits de dados. A explicação pode ser melhor visualizada através da figura .

     O mais interessante de tudo é a forma pela qual o bit errado é identificado. Ele é indicado pelos valores de p1, p2 e p4 armazenados e calculados. Quando esses bits armazenados são iguais aos calculados, recebem peso zero, quando são diferentes, recebem peso 1, 2 ou 4 respectivamente. Por exemplo, quando p1 calculado é igual ao p1 armazenado, p2 calculado é diferente do p2 armazenado, e p4 calculado é igual ao p4 armazenado, temos 0+2+4=6. Isto significa que o bit b6 está errado. Basta invertê-lo (trocar de 0 para 1, ou de 1 para 0) e o erro estará corrigido.
     Com dados de 64 bits, são usados os bits de checagem p1, p2, p4, p8, p16 e p32, além de pd para indicar a paridade dos dados e pp para indicar a paridade dos bits de checagem. São portanto 8 bits de checagem ao todo. O mesmo esquema da figura é utilizado, e os bits p1, p2, p4, p8, p16 e p32 são usados para indicar a posição do erro.
     OBS: Essa história de código de Laercius é brincadeira. Não sou o criador deste método, estou apenas repetindo o que aprendi em alguma aula de circuitos digitais, lá pelo início dos anos 80...
     Você não precisa conhecer os métodos utilizados pelos chipsets para detectar e corrigir erros na memória, mas precisa saber o seguinte:
     a) para cada grupo de 64 bits, são necessários 8 bits adicionais para implementar o ECC, totalizando 72 bits.
     b) Não adianta simplesmente usar memórias de 72 bits. É preciso que o chipset da sua placa de CPU utilize a geração e a checagem de erros. Muitos chipsets para PCs de baixo custo não operam com ECC.