Por que o memtest mostra um bitflip do mesmo bit em vários endereços?

Question

Eu tive a experiência infeliz de falhar um memtest hoje, mas os resultados parecem um pouco peculiares e tenho várias perguntas sobre eles. É claro que isso provavelmente terminará comigo devolvendo a RAM, mas eu ainda quero entender o que deu errado.

Memtest log pastebin

O que eu notei ser peculiar foi que, em vários endereços, sempre foi o último bit do primeiro byte que falhou. Aqui está uma seção do log mostrando isso.

2018-01-27 07:19:35 - [MEM ERROR - Data] Test: 6, CPU: 1, Address: 252A019F8, Expected: FEF7FFFF, Actual: FFF7FFFF
2018-01-27 07:19:35 - [MEM ERROR - Data] Test: 6, CPU: 1, Address: 253201A38, Expected: FEFEFFFF, Actual: FFFEFFFF
2018-01-27 07:19:35 - [MEM ERROR - Data] Test: 6, CPU: 2, Address: 255641A98, Expected: FEF7FFFF, Actual: FFF7FFFF
2018-01-27 07:19:35 - [MEM ERROR - Data] Test: 6, CPU: 2, Address: 255E41CB8, Expected: 00000000, Actual: 01000000
2018-01-27 07:19:35 - [MEM ERROR - Data] Test: 6, CPU: 2, Address: 257641A78, Expected: FEF7FFFF, Actual: FFF7FFFF
2018-01-27 07:19:35 - [MEM ERROR - Data] Test: 6, CPU: 2, Address: 257E41C98, Expected: 00000000, Actual: 01000000
2018-01-27 07:19:35 - [MEM ERROR - Data] Test: 6, CPU: 3, Address: 259201A58, Expected: FEFEFFFF, Actual: FFFEFFFF
2018-01-27 07:19:35 - [MEM ERROR - Data] Test: 6, CPU: 3, Address: 259201B58, Expected: FEEFFFFF, Actual: FFEFFFFF
2018-01-27 07:19:35 - [MEM ERROR - Data] Test: 6, CPU: 3, Address: 259645310, Expected: 01004000, Actual: 00004000
2018-01-27 07:19:36 - [MEM ERROR - Data] Test: 6, CPU: 3, Address: 259A01A18, Expected: FEFFF7FF, Actual: FFFFF7FF
2018-01-27 07:19:36 - [MEM ERROR - Data] Test: 6, CPU: 3, Address: 259A01AD8, Expected: FEFFBFFF, Actual: FFFFBFFF
2018-01-27 07:19:36 - [MEM ERROR - Data] Test: 6, CPU: 3, Address: 25B201A38, Expected: FEFEFFFF, Actual: FFFEFFFF
2018-01-27 07:19:36 - [MEM ERROR - Data] Test: 6, CPU: 3, Address: 25B201B38, Expected: FEEFFFFF, Actual: FFEFFFFF

Eu testei a RAM em dois computadores diferentes e resultou no mesmo erro. Esses resultados me dizem alguma coisa sobre o erro na lógica interna que está acontecendo? Eu acho que é porque um conjunto de bytes compartilha a mesma lógica de endereçamento, mas eu esperaria que as falhas fossem seqüenciais em bytes de memória. Ou será que o bit com falha em todos esses endereços é o mesmo e, por algum motivo, o mesmo byte recebe um endereço diferente a cada nova execução?

Em segundo lugar, o memtest só falhou em alguns testes, especificamente, ele não falhou nos testes de 0 a 2, mesmo depois de vários memtests. Eu só tenho conhecimento básico do que cada teste faz, mas estou surpreso que os primeiros testes nunca resultaram em erro. Alguma razão pela qual?

    

Answer 1

Isso pode ser por causa do layout descrito neste artigo da Wikipédia: row hammer .

In dynamic RAM (DRAM), each bit of stored data occupies a separate memory cell […]

Memory cells (blue squares in the illustration) are further organized into matrices and addressed through rows and columns. A memory address applied to a matrix is broken into the row address and column address, which are processed by the row and column address decoders (in the illustration, vertical and horizontal green rectangles, respectively). After a row address selects the row for a read operation (the selection is also known as row activation), bits from all cells in the row are transferred into the sense amplifiers that form the row buffer (red squares in the illustration), from which the exact bit is selected using the column address.

_{Fonte da foto (domínio público)}

Hipótese: há algo errado com um bit de um certo buffer de linha (quadrados vermelhos); isso afeta a leitura de qualquer linha correspondente ao buffer. Eu não estou afirmando que isso acontecerá toda vez, para cada linha e qualquer dado escrito; No entanto, acredito que este formulário de matriz e o buffer de linha (ou algo semelhante) tenham algo a ver com o fato de que é sempre o último bit do primeiro byte que falhou.

Secondly, the memtest only failed a few tests, specifically it did not fail tests 0 through 2 […]. I am surprised that the first few tests never resulted in an error. Any reason why?

Este manual explica quais são os testes:

• 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.

Eu entendo que os testes 0-2 são projetados para capturar erros de endereçamento, não necessariamente erros de dados reais. Observe se eles foram capazes de detectar todos os erros, então testes adicionais não seriam necessários.