Como eu interpreto as estatísticas de uma execução do memtest?

59

Eu tenho um notebook aqui que eu suspeito que tenha um módulo de memória defeituoso. Eu, portanto, baixei o Memtest86 + e o deixei rodar.

Observe que a captura de tela não é minha real, é fornecida pelo memtest86 +

Como interpreto os números na tela? Deixei correr 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

indica? Quais são os valores sensatos para erros de memória? Em que ponto devo considerar a substituição de memória?

    
por slhck 21.08.2011 / 21:17

3 respostas

74

TL; DR

O número mais importante primeiro: A contagem de erros para memória saudável deve ser 0 . Qualquer número acima de 0 pode indicar setores danificados / com defeito.

Explicação de 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 vários testes, grava padrões específicos em todos os setores da memória e os recupera. Se os dados recuperados diferirem dos dados originalmente armazenados, o MemTest registra um erro e aumenta a contagem de erros em um. Erros são geralmente sinais de faixas ruins de RAM.

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

Alguns exemplos de teste (simplificados):

  • Teste os setores nesta ordem: A, B, C, D, E, F. (Serial)
  • Teste os setores 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 de: link

Test 0 [Address test, walking ones, no cache]

Tests all address bits in all memory banks by using a walking ones address pattern.

Test 1 [Address test, own address, Sequential]

Each address is written with its own address and then is checked for consistency. In theory previous tests should have caught any memory addressing problems. This test should catch any addressing errors that somehow were not previously detected. This test is done sequentially with each available CPU.

Test 2 [Address test, own address, Parallel]

Same as test 1 but the testing is done in parallel using all CPUs and using overlapping addresses.

Test 3 [Moving inversions, ones&zeros, Sequential]

This test uses the moving inversions algorithm with patterns of all ones and zeros. Cache is enabled even though it interferes to some degree with the test algorithm. With cache enabled this test does not take long and should quickly find all "hard" errors and some more subtle errors. This test is only a quick check. This test is done sequentially with each available CPU.

Test 4 [Moving inversions, ones&zeros, Parallel]

Same as test 3 but the testing is done in parallel using all CPUs.

Test 5 [Moving inversions, 8 bit pat]

This is the same as test 4 but uses a 8 bit wide pattern of "walking" ones and zeros. This test will better detect subtle errors in "wide" memory chips.

Test 6 [Moving inversions, random pattern]

Test 6 uses the same algorithm as test 4 but the data pattern is a random number and it's complement. This test is particularly effective in finding difficult to detect data sensitive errors. The random number sequence is different with each pass so multiple passes increase effectiveness.

Test 7 [Block move, 64 moves]

This test stresses memory by using block move (movsl) instructions and is based on Robert Redelmeier's burnBX test. Memory is initialized with shifting patterns that are inverted every 8 bytes. Then 4mb blocks of memory are moved around using the movsl instruction. After the moves are completed the data patterns are checked. Because the data is checked only after the memory moves are completed it is not possible to know where the error occurred. The addresses reported are only for where the bad pattern was found. Since the moves are constrained to a 8mb segment of memory the failing address will always be less than 8mb away from the reported address. Errors from this test are not used to calculate BadRAM patterns.

Test 8 [Moving inversions, 32 bit pat]

This is a variation of the moving inversions algorithm that shifts the data pattern left one bit for each successive address. The starting bit position is shifted left for each pass. To use all possible data patterns 32 passes are required. This test is quite effective at detecting data sensitive errors but the execution time is long.

Test 9 [Random number sequence]

This test writes a series of random numbers into memory. By resetting the seed for the random number the same sequence of number can be created for a reference. The initial pattern is checked and then complemented and checked again on the next pass. However, unlike the moving inversions test writing and checking can only be done in the forward direction.

Test 10 [Modulo 20, ones&zeros]

Using the Modulo-X algorithm should uncover errors that are not detected by moving inversions due to cache and buffering interference with the the algorithm. As with test one only ones and zeros are used for data patterns.

Test 11 [Bit fade test, 90 min, 2 patterns]

The bit fade test initializes all of memory with a pattern and then sleeps for 5 minutes. Then memory is examined to see if any memory bits have changed. All ones and all zero patterns are used.

Como os setores defeituosos podem às vezes funcionar e não funcionar em outro momento, recomendo que o MemTest execute alguns passos. Uma passagem completa é uma série de testes concluída que foi aprovada. (As séries de testes anteriores 1-11) Quanto mais passes você obtiver sem erros, mais preciso será o seu MemTest. Eu costumo correr em torno de 5 passes para ter certeza.

A contagem de erros para memória saudável deve ser 0. Qualquer número acima de 0 pode indicar setores danificados / com problemas.

Contagem de erros de ECC só deve ser considerada quando ECC estiver definido como off . ECC significa Error-correction code memory e é um mecanismo para detectar e corrigir bits errados em um estado de memória. Ele pode ser comparado à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 servidor. A contagem de ECC conta quantos erros foram corrigidos pelo mecanismo ECC da memória. O ECC não deve ter que ser invocado para RAM saudável, portanto, uma contagem de erros de ECC acima de 0 também pode indicar memória ruim.

Explicação de erros

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

Aprimeiracoluna(Tst)mostraqualtestefalhou,onúmerocorrespondeaonúmerodotestedalistajámencionadaacima.Asegundacoluna(Pass)mostraseotestefoipassado.Nocasodoexemplo,oteste7nãotempasses.

Aterceiracoluna(FalhaEndereço)mostraexatamentequalpartedamemóriatemerros.Essapartetemumendereço,muitoparecidocomumendereçoIP,queéexclusivoparaessepedaçodearmazenamentodedados.Elemostraqualendereçofalhouequalotamanhodoblocodedados.(0,8MBnoexemplo)

Ascolunasquarto(Bom)equinto(Ruim)mostramosdadosqueforamgravadoseoquefoirecuperado,respectivamente.Ambasascolunasdevemseriguaisemmemórianãodefeituosa(obviamente).

Asextacoluna(Err-Bits)mostraaposiçãodosbitsexatosqueestãofalhando.

Asétimacoluna(Contagem)mostraonúmerodeerrosconsecutivoscomomesmoendereçoebitscomfalha.

Finalmente,aúltimacolunasete(Chan)mostraocanal(sevárioscanaissãousadosnosistema)emqueafaixadememóriaestá.

Seencontrarerros

SeoMemTestdescobriralgumerro,omelhormétodoparadeterminarqualmóduloestácomdefeitoécobertoem esta pergunta de super usuário e sua resposta aceita:

Use the process of elimination -- remove half of the modules and run the test again...

If there are no failures, then you know that these two modules are good, so put them aside and test again.

If there are failures, then cut down to half again (down to one of four memory modules now) then test again.

But, just because one failed a test, don't assume that the other doesn't fail (you could have two failing memory modules) -- where you've detected a failure with two memory modules, test each of those two separately afterwards.

Important note: With features like memory interleaving, and poor memory module socket numbering schemes by some motherboard vendors, it can be difficult to know which module is represented by a given address.

    
por 21.08.2011 / 22:13
6

Número de erros

Ao passar pelos testes, se a memória falhar em algum dos testes, isso aumentará o número de erros. Se bem me lembro, ele 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 que é usado para impedir que os dados sejam corrompidos. Sua coluna ECC Errs 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 de teste

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

Teste 0: Teste de endereço do Walking Ones

O Memtest escreverá 00000001 no primeiro local da memória, 00000010 no 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 escreve cada local da memória com seu próprio endereço e verifica se o valor não foi alterado.

O teste 1 é sequencial e o teste 2 é paralelo (isto é, usa simultaneidade).

Teste 3 e 4 Teste de inversão de movimento

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

  1. leva cada local da memória (a partir da primeira / mais baixa localização),
  2. e escreve o inverso do padrão (eu acredito que é um NÃO bit a bit, mas não consegui encontrar nenhuma documentação sobre isso).

O objetivo aqui é tentar testar cada bit 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 faz.

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

Isso faz o método de inversões de movimento novamente, mas desta vez com o 1s de caminhada 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 de caminhada.

Teste 7: movimento de bloco

Isso é divertido. Carrega padrões na memória, move-os em blocos de 4MB e os verifica.

Teste 8: Movendo Inversão, Pat de 32 bits

O mesmo que o teste 5, mas usa blocos de 32 bits. Este, de fato, 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. A coisa legal sobre o gerador de números pseudo-aleatórios é que não é muito aleatório (se você já executou printf("%d", rand()); em um programa C sem propagação e obteve o oh-tão-aleatório 41, você sabe o que quero dizer). Por isso, ele verifica, reiniciando a semeadora de números aleatórios e executando o gerador novamente.

Teste 10: Módulo-X

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

Teste 11: teste de desvanecimento de bits

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

    
por 21.08.2011 / 23:10
6

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 tem ECC, então esse número não importa.

Se a sua memória tiver qualquer número de erros acima de 0, você vai querer substituí-lo.

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

A contagem indica o número de vezes que o resultado lido de volta no memtest não corresponde ao que foi escrito na memória, significando que há um erro no bloco de memória que está sendo testado.

ECC é uma tecnologia de correção de erros embutida em chips de memória para servidores e estações de trabalho. A maioria dos dekstops não suportam módulos de memória com ECC embutido. Quase todos os servidores / estações de trabalho têm suporte para isso e geralmente exigem isso. O número de erros corrigidos pelo ECC é o número de erros que o chip ECC consertou com sucesso.

    
por 21.08.2011 / 21:43