Eu tenho um notebook aqui que suspeito ter um módulo de memória com defeito. Portanto, baixei o Memtest86 + e o deixei rodar.

_{Observe que a captura de tela não é a atual, é fornecida pelo memtest86 +}

Como interpreto os números na tela? Deixei que funcionasse por cerca de quatro horas e agora estou no passe 7.

Especialmente, o que faz

• o número do teste
• a contagem de erros
• a contagem de erros de ECC

indicar? Quais são os valores sãos para erros de memória? Em que momento devo considerar a substituição da memória?

TL; DR

O número mais importante primeiro: a contagem de erros para a memória íntegra deve ser 0 . Qualquer número acima de 0 pode indicar setores danificados / defeituosos.

Explicação da tela

     Memtest86+ v1.00      | Progress of the entire pass (test series)
CPU MODEL and clock speed  | Progress of individual, current test
Level 1 cache size & speed | Test type that is currently running
Level 2 cache size & speed | Part of the RAM (sector) that is being tested
RAM size and testing speed | Pattern that is being written to the sector
Information about the chipset that your mainboard uses
Information about your RAM set-up, clock speed, channel settings, etc.

WallTime   Cached  RsvdMem   MemMap   Cache  ECC  Test  Pass  Errors  ECC Errs
---------  ------  -------  --------  -----  ---  ----  ----  ------  --------
Elapsed    Amount  Amount    Mapping  on     on   Test  # of  # of    # of ECC
time       of RAM  of        used     or     or   type  pass  errors  errors
           cached  reserved           off    off        done  found   found
                   RAM, not
                   tested

Explicação de dados / teste

O MemTest executa uma série de testes, grava padrões específicos em todos os setores da memória e os recupera. Se os dados recuperados diferirem dos que foram originalmente armazenados, o MemTest registra um erro e aumenta a contagem de erros em um. Erros geralmente são sinais de faixas de RAM ruins.

Como a memória não é apenas um bloco de notas que contém informações, mas possui funções avançadas como cache, vários testes diferentes são feitos. Isto é o que Test #indica. O MemTest executa vários testes diferentes para verificar se ocorrem erros.

Alguns exemplos de teste (simplificados):

• Setores de teste nesta ordem: A, B, C, D, E, F. (Serial)
• Setores de teste nesta ordem: A, C, E, B, D, F. (Movendo)
• Preencha todos os setores com padrão: aaaaaaaa
• Preencha todos os setores com um padrão aleatório.

Descrição mais detalhada de todos os testes em: https://www.memtest86.com/technical.htm#detailed

Teste 0 [Teste de endereço, caminhadas, sem cache]

Testa todos os bits de endereço em todos os bancos de memória usando um padrão de endereço móvel.

Teste 1 [Teste de endereço, endereço próprio, Sequencial]

Cada endereço é escrito com seu próprio endereço e, em seguida, é verificado quanto à consistência. Em teoria, testes anteriores deveriam ter detectado problemas de memória. Este teste deve detectar erros de endereçamento que de alguma forma não foram detectados anteriormente. Este teste é feito seqüencialmente com cada CPU disponível.

Teste 2 [Teste de endereço, endereço próprio, Paralelo]

Igual ao teste 1, mas o teste é realizado em paralelo, usando todas as CPUs e endereços sobrepostos.

Teste 3 [Movendo inversões, uns e zeros, Sequencial]

Este teste usa o algoritmo de inversões móveis com padrões de todos os zeros. O cache está ativado, embora interfira em algum grau no algoritmo de teste. Com o cache ativado, esse teste não leva muito tempo e deve encontrar rapidamente todos os erros "difíceis" e alguns erros mais sutis. Este teste é apenas uma verificação rápida. Este teste é feito seqüencialmente com cada CPU disponível.

Teste 4 [Movendo inversões, uns e zeros, Paralelo]

Igual ao teste 3, mas o teste é feito em paralelo usando todas as CPUs.

Teste 5 [inversões móveis, 8 bits pat]

É o mesmo que o teste 4, mas usa um padrão de 8 bits de zeros e uns "andantes". Este teste detectará melhor erros sutis em chips de memória "amplos".

Teste 6 [inversões móveis, padrão aleatório]

O teste 6 usa o mesmo algoritmo do teste 4, mas o padrão de dados é um número aleatório e é um complemento. Este teste é particularmente eficaz em encontrar dificuldades para detectar erros sensíveis aos dados. A sequência numérica aleatória é diferente a cada passagem, portanto, várias passagens aumentam a eficácia.

Teste 7 [Movimento de bloco, 64 movimentos]

Esse teste enfatiza a memória usando instruções de movimentação de bloco (movsl) e é baseado no teste burnBX de Robert Redelmeier. A memória é inicializada com padrões de deslocamento que são invertidos a cada 8 bytes. Em seguida, blocos de 4 MB de memória são movidos usando a instrução movsl. Após a conclusão das mudanças, os padrões de dados são verificados. Como os dados são verificados somente após a movimentação da memória, não é possível saber onde ocorreu o erro. Os endereços relatados são apenas para onde o padrão ruim foi encontrado. Como as movimentações são restritas a um segmento de 8 MB de memória, o endereço com falha estará sempre a menos de 8 MB do endereço relatado. Erros deste teste não são usados ​​para calcular padrões BadRAM.

Teste 8 [inversões móveis, 32 bits pat]

Essa é uma variação do algoritmo de inversões móveis que muda o padrão de dados deixado um bit para cada endereço sucessivo. A posição do bit inicial é deslocada para a esquerda para cada passe. Para usar todos os padrões de dados possíveis, são necessárias 32 passagens. Este teste é bastante eficaz na detecção de erros sensíveis a dados, mas o tempo de execução é longo.

Teste 9 [Sequência numérica aleatória]

Este teste grava uma série de números aleatórios na memória. Ao redefinir a semente para o número aleatório, a mesma sequência de números pode ser criada para uma referência. O padrão inicial é verificado e, em seguida, complementado e verificado novamente no próximo passe. No entanto, diferentemente das inversões em movimento, a escrita e a verificação só podem ser feitas na direção direta.

Teste 10 [Módulo 20, uns e zeros]

O uso do algoritmo Modulo-X deve descobrir erros que não são detectados movendo inversões devido a interferências de cache e buffer no algoritmo. Como no teste, apenas um e zeros são usados ​​para padrões de dados.

Teste 11 [Teste de desbotamento por bits, 90 min, 2 padrões]

O teste de desbotamento em bits inicializa toda a memória com um padrão e dorme por 5 minutos. Em seguida, a memória é examinada para verificar se algum bit de memória foi alterado. Todos os padrões zero e todos são usados.

Como setores defeituosos às vezes funcionam e não funcionam outra vez, recomendo deixar o MemTest executar algumas etapas. Uma aprovação completa é uma série de testes concluída que já passou. (A série de testes 1-11 acima) Quanto mais passes você obtiver sem erros, mais precisa será a sua execução no MemTest. Eu costumo executar cerca de 5 passes para ter certeza.

A contagem de erros da memória íntegra deve ser 0. Qualquer número acima de 0 pode indicar setores danificados / com defeito.

A contagem de erros do ECC deve ser levada em consideração apenas quando ECCdefinida como off. ECC significa Memória de código de correção de erros e é um mecanismo para detectar e corrigir bits incorretos no estado da memória. Pode ser comparado ligeiramente às verificações de paridade feitas em RAID ou mídia óptica. Essa tecnologia é bastante cara e provavelmente só será encontrada em configurações de servidores. A contagem de ECC conta quantos erros foram corrigidos pelo mecanismo ECC da memória. O ECC não deve ter que ser chamado para uma RAM saudável; portanto, uma contagem de erros do ECC acima de 0 também pode indicar memória insuficiente.

Explicação do erro

Exemplo de Memtest que encontrou erros. Mostra qual setor / endereço falhou.

A primeira coluna ( Tst ) mostra qual teste falhou, o número corresponde ao número de teste da lista já mencionada acima. A segunda coluna ( passagem ) mostra se que o teste tenha passado. No caso do exemplo, o teste 7 não tem aprovação.

A terceira coluna ( Endereço com falha ) mostra exatamente qual parte da memória possui erros. Essa parte possui um endereço, como um endereço IP, exclusivo para esse pedaço de armazenamento de dados. Ele mostra qual endereço falhou e qual o tamanho do bloco de dados. (0,8 MB no exemplo)

A quarta ( boa ) e a quinta ( ruim ) coluna mostram os dados que foram gravados e o que foi recuperado, respectivamente. Ambas as colunas devem ser iguais na memória não defeituosa (obviamente).

A sexta coluna ( Err-Bits ) mostra a posição dos bits exatos que estão falhando.

A sétima coluna ( Contagem ) mostra o número de erros consecutivos com o mesmo endereço e bits com falha.

Finalmente, a última coluna sete ( Chan ) mostra o canal (se vários canais forem usados ​​no sistema) em que a faixa de memória está.

Se encontrar erros

Se o MemTest detectar algum erro, o melhor método para determinar qual módulo está com defeito é abordado nesta pergunta do superusuário e sua resposta aceita:

Use o processo de eliminação - remova metade dos módulos e execute o teste novamente ...

Se não houver falhas, você saberá que esses dois módulos são bons; então, deixe-os de lado e teste novamente.

Se houver falhas, reduza para metade novamente (reduza para um dos quatro módulos de memória agora) e teste novamente.

Mas, apenas porque um falhou em um teste, não assuma que o outro não falha (você pode ter dois módulos de memória com falha) - onde você detectou uma falha com dois módulos de memória, teste cada um deles separadamente posteriormente. .

Nota importante: Com recursos como intercalação de memória e esquemas de numeração de soquete de módulo de memória insuficiente por alguns fornecedores de placas-mãe, pode ser difícil saber qual módulo é representado por um determinado endereço.

Número de erros

Ao passar pelos testes, se a memória falhar em algum dos testes, aumentará o número de erros. Se bem me lembro, conta o número de endereços que falharam no teste.

Número de erros de ECC

A memória ECC é um tipo especial de chip de memória usado para impedir que os dados sejam corrompidos. Sua ECC Errscoluna conta quantos problemas foram corrigidos pelo ECC.

(O ECC é lento e caro e é basicamente para sistemas de missão crítica que não podem ser incomodados em trocar a RAM.)

Número do teste

O Memtest faz diferentes tipos de testes em sua memória, descritos no site do Memtest86 . Assim como uma tradução rápida e simples para o inglês:

Teste 0: Teste de Endereços para Caminhar

O Memtest gravará 00000001no primeiro local da memória, 00000010no próximo e assim por diante, repetindo esse padrão a cada 8 bytes. Em seguida, ele lê a memória e garante que o valor não foi alterado. ( Fonte )

Testes 1 e 2: Teste de endereço de endereço próprio

O Memtest grava cada local de memória com seu próprio endereço e verifica se o valor não foi alterado.

O teste 1 é seqüencial e o teste 2 é paralelo (ou seja, usa simultaneidade).

Teste 3 e 4 Teste de Inversões Móveis

Em essência, esse teste carrega 0s na memória e, em seguida,

1. pega cada local da memória (a partir do primeiro / mais baixo local),
2. e escreve o inverso do padrão (eu acreditaria que não é um bit a bit, mas não consegui encontrar nenhuma documentação sobre isso).

O objetivo aqui é tentar testar todos os bits e seus bits adjacentes "todas as combinações possíveis de 0s e 1s".

O teste 3 não usa simultaneidade, enquanto o teste 4 usa.

Teste 5: Movendo Inversões, Pat de 8 bits

Isso faz o método de inversões em movimento novamente, mas desta vez com os 1s andando do teste 0 em blocos de 8 bits.

Teste 6: Movendo Inversões, Padrão Aleatório

O Memtest usa números aleatórios em vez de todos os 0s ou 1s andantes.

Teste 7: movimento do bloco

Essa é divertida. Carrega padrões na memória, move-os em blocos de 4mb e os verifica.

Teste 8: Inversão em movimento, Pat de 32 bits

O mesmo que o teste 5, mas usa blocos de 32 bits. De fato, este carrega todos os valores possíveis de 32 bits em todos os locais.

Teste 9: Números Aleatórios

Este carrega números pseudo-aleatórios na memória e verifica. O interessante do gerador de números pseudoaleatórios é que ele não é muito aleatório (se você já rodou printf("%d", rand());em um programa C sem propagação e conseguiu o 41, você sabe o que quero dizer). Por isso, verifica redefinindo o semeador de números aleatórios e executando o gerador novamente.

Teste 10: Módulo X

A cada 20 locais, ele grava um padrão (todos os 0s ou todos os 1s) e grava o complemento em todos os outros locais e depois verifica.

Teste 11: Teste de desbotamento por bits

Este carrega a RAM com todos os 1s (e novamente com todos os 0s), aguarda 5 minutos e verifica se algum dos valores muda.

Número do teste: o número do teste específico que o memtest está executando no momento. Existem muitos deles.

Contagem de erros: o número de erros de memória encontrados

Erros de ECC: Número de erros corrigidos pelo ECC. Seu chipset / memória não possui ECC, portanto esse número não importa.

Se sua memória tiver algum número de erros acima de 0, convém substituí-la.

EDIT: Os testes são os diferentes padrões que o memtest grava na memória. Ele grava padrões diferentes na memória e os lê novamente para verificar se há erros, e usa padrões diferentes para poder testar todos os estados de todos os bits.

A contagem indica o número de vezes que o resultado lido novamente no memtest não corresponde ao que ele gravou na memória, significando que há um erro no pedaço de memória sendo testado.

O ECC é uma tecnologia de correção de erros incorporada aos chips de memória para servidores e estações de trabalho. A maioria dos dekstops não suporta módulos de memória com o ECC embutido. Quase todos os servidores / estações de trabalho têm suporte para ele, e geralmente precisam dele. O número de erros corrigidos pelo ECC é o número de erros que o chip ECC corrigiu com sucesso.