Unofficial

MemHound: een RAM-test voor een draaiende NAS

Eén statisch programma test via SSH het vrije geheugen van een QNAP NAS. De LiveCD test bijna al het geheugen van een pc of een x86-NAS.

MemHound neemt het vrije geheugen in blokken van 128 MB. Het vergrendelt elk blok in het RAM, schrijft er testpatronen in en leest ze terug. Voor elk foutief woord toont het het fysieke adres.

De NAS blijft tijdens de test bestanden leveren. MemHound houdt 256 MB geheugen vrij en draait met de laagste prioriteit. Als het geheugen opraakt, stopt het systeem MemHound vóór elk ander programma.

Versie 0.6.10 · x86_64, aarch64 en armhf · QTS en QuTS hero · freeware

  • 128MB in elk blok dat MemHound vergrendelt en test
  • 256MB geheugen die altijd vrij blijft voor de NAS
  • 21tests op elk blok in een Extended-ronde

Zo verloopt een test

Zonder opties voert MemHound de hele RAM-test uit in vier stappen. Stap 3 herhaalt zich tot je op q drukt.

  1. Geheugen vrijmaken

    MemHound schrijft de cache naar de schijf en verwijdert hem. Op QuTS hero leegt het ook de ZFS ARC. De test kan dan meer geheugen gebruiken.

    sync, drop_caches, zinject -a
  2. Quick-ronde

    Drie tests op elk blok: de adrestest, een dambordpatroon en moving inversions met willekeurige waarden.

    86 ms voor elk blok van 128 MB
  3. Extended-rondes

    21 tests op elk blok. Voor elke ronde maakt MemHound het geheugen opnieuw vrij. De rondes herhalen zich tot je op q drukt of MemHound een fout vindt.

    5,3 s voor elk blok van 128 MB
  4. Het resultaat

    Een groot woord toont het resultaat. Daaronder staan twee regels: wat MemHound vond en wat je daarna doet. Daarna volgt de volledige samenvatting.

    Tested X MB of Y MB (Z%)

Binnen een ronde: één blok tegelijk

Een ronde houdt niet al het vrije geheugen tegelijk vast. Ze test één blok en geeft het daarna vrij:

  1. MemHound neemt 128 MB vrij geheugen en vergrendelt het met mlock. Het systeem kan het dan niet naar swap verplaatsen.
  2. Het voert eerst de adrestest uit. Als deze test mislukt, markeert MemHound alle andere resultaten als onzeker.
  3. Het voert de patroontests uit. Elke test schrijft het hele blok, duwt het uit de CPU-cache en leest het daarna terug.
  4. Het geeft het blok vrij en neemt het volgende. Voor elk blok controleert het dat 256 MB vrij blijft.

Als een woord fout wordt teruggelezen, leest MemHound het tot 8 keer opnieuw en bewaart het fysieke adres. Een fout die zich op hetzelfde adres herhaalt, is een harde fout. Een fout die zich niet herhaalt, is een transiënte fout.

De 21 tests van een Extended-ronde

De tijd van elke test op één blok van 128 MB. We hebben die gemeten met MemHound 0.6.10 op een QNAP NAS met een Intel Core i5-1235U en 16 GB RAM. Wijs een balk aan om te zien wat de test schrijft.

Eén blok van 128 MB, alle tests

  • Quick-ronde86 ms
  • Extended-ronde5 337 ms
  • Adrestest, de eerste in elke ronde
  • Ook in de Quick-ronde
  • Standaardtests
  • Vergelijkingstests
  • stuck-addr14 msSchrijft het adres van elk woord in dat woord en leest daarna elk woord terug.
  • solid013 msSchrijft alle bits 0 en leest ze daarna terug.
  • solid114 msSchrijft alle bits 1 en leest ze daarna terug.
  • checker24 msSchrijft afwisselend bits 0 en 1, daarna het omgekeerde patroon.
  • movinv028 msMoving inversions: vult met 0, leest en inverteert daarna elk woord, eerst omhoog, dan omlaag.
  • movinv126 msDezelfde moving inversions, beginnend met alle bits 1.
  • movinv-rand31 msMoving inversions met willekeurige waarden die een seed kan herhalen.
  • modulo20250 msSchrijft een waarde in elk 20e woord en de inverse ervan in alle andere woorden, 20 keer.
  • walk1 590 msSchuift één 1-bit door elke positie van het woord, daarna één 0-bit.
  • movinv8206 msMoving inversions met 8 bytepatronen, met in elk één gezette bit.
  • blockseq209 msVult het blok met 16 bytewaarden (00, 55, AA, FF en andere) en leest elke waarde terug.
  • bitflip1 626 msWisselt een woord met één gezette bit af met een woord waarin alleen die bit gewist is, voor elk van de 64 bits.
  • bitspread805 msHetzelfde met twee aangrenzende bits, voor elk aangrenzend paar van de 64 bits.
  • rand-dual71 msSchrijft dezelfde willekeurige waarden in beide helften van het blok en vergelijkt de helften.
  • cmp-xor58 msBeide helften krijgen willekeurige waarden die met één getal via XOR gecombineerd zijn, daarna vergelijkt MemHound ze.
  • cmp-sub58 msDezelfde vergelijking, met aftrekken.
  • cmp-mul58 msDezelfde vergelijking, met vermenigvuldigen.
  • cmp-div66 msDezelfde vergelijking, met delen.
  • cmp-or58 msDezelfde vergelijking, met OR.
  • cmp-and57 msDezelfde vergelijking, met AND.
  • seqinc75 msDezelfde vergelijking, met waarden die van woord tot woord oplopen.
De meeste tests duren minder dan 0,1 s. walk en bitflip duren elk 1,6 s, omdat ze één bit door elke positie van een 64-bits woord schuiven.
Toon de getallen als tabel
TestGroepmsWat hij doet
stuck-addrAdrestest, de eerste in elke ronde14Schrijft het adres van elk woord in dat woord en leest daarna elk woord terug.
solid0Standaardtests13Schrijft alle bits 0 en leest ze daarna terug.
solid1Standaardtests14Schrijft alle bits 1 en leest ze daarna terug.
checkerOok in de Quick-ronde24Schrijft afwisselend bits 0 en 1, daarna het omgekeerde patroon.
movinv0Standaardtests28Moving inversions: vult met 0, leest en inverteert daarna elk woord, eerst omhoog, dan omlaag.
movinv1Standaardtests26Dezelfde moving inversions, beginnend met alle bits 1.
movinv-randOok in de Quick-ronde31Moving inversions met willekeurige waarden die een seed kan herhalen.
modulo20Standaardtests250Schrijft een waarde in elk 20e woord en de inverse ervan in alle andere woorden, 20 keer.
walkStandaardtests1 590Schuift één 1-bit door elke positie van het woord, daarna één 0-bit.
movinv8Standaardtests206Moving inversions met 8 bytepatronen, met in elk één gezette bit.
blockseqStandaardtests209Vult het blok met 16 bytewaarden (00, 55, AA, FF en andere) en leest elke waarde terug.
bitflipStandaardtests1 626Wisselt een woord met één gezette bit af met een woord waarin alleen die bit gewist is, voor elk van de 64 bits.
bitspreadStandaardtests805Hetzelfde met twee aangrenzende bits, voor elk aangrenzend paar van de 64 bits.
rand-dualStandaardtests71Schrijft dezelfde willekeurige waarden in beide helften van het blok en vergelijkt de helften.
cmp-xorVergelijkingstests58Beide helften krijgen willekeurige waarden die met één getal via XOR gecombineerd zijn, daarna vergelijkt MemHound ze.
cmp-subVergelijkingstests58Dezelfde vergelijking, met aftrekken.
cmp-mulVergelijkingstests58Dezelfde vergelijking, met vermenigvuldigen.
cmp-divVergelijkingstests66Dezelfde vergelijking, met delen.
cmp-orVergelijkingstests58Dezelfde vergelijking, met OR.
cmp-andVergelijkingstests57Dezelfde vergelijking, met AND.
seqincVergelijkingstests75Dezelfde vergelijking, met waarden die van woord tot woord oplopen.

De adrestest

Een geheugenmodule vindt een woord via zijn adres. Als een adreslijn kapot is, leiden twee adressen naar dezelfde cel. Dan kan een patroontest dezelfde verkeerde cel schrijven en lezen zonder een fout te zien.

Daarom draait de adrestest als eerste, op elk blok. Hij schrijft het adres van elk woord in dat woord. Daarna leest hij elk woord terug. Een woord dat het adres van een ander woord bevat, wijst op een kapotte adreslijn.

Als de adrestest mislukt, is het resultaat CRITICAL: de andere tests van die testrun bewijzen dan niets.

Een goede module

AdresGeschrevenTeruggelezen
100010001000
100810081008
101010101010
101810181018
102010201020
102810281028
103010301030
103810381038

Adreslijn 5 vast op 0

AdresGeschrevenTeruggelezen
100010001020
100810081028
101010101030
101810181038
102010201020
102810281028
103010301030
103810381038
Met lijn 5 vast komen de schrijfacties naar 1020 tot 1038 terecht in de cellen van 1000 tot 1018. De eerste vier woorden geven dan de verkeerde adressen terug.

Wat elk resultaat betekent

Aan het eind van een test die je zelf hebt gestart, toont MemHound een van zes woorden in grote letters. Een test vanuit de app StorageDiag, het USB-image of het aftellen van de LiveCD toont dit scherm niet.

  • PASSED

    Geen fouten. In de hele test bereikte MemHound ook minstens 80% van het RAM.

    Het geheugen is goed.

  • BAD RAM

    Harde fouten: een fout herhaalt zich op hetzelfde adres.

    De geheugenmodule is verdacht. De samenvatting toont de adressen.

  • CRITICAL

    De adrestest is mislukt: sommige adressen verliezen hun gegevens.

    De geheugenmodule of de geheugencontroller is verdacht.

  • FAILED

    Alleen transiënte fouten: ze herhaalden zich niet op hetzelfde adres.

    Voeding, warmte of geheugentiming kunnen ze veroorzaken. Voer de test opnieuw uit.

  • PARTIAL

    Geen fouten, maar MemHound testte minder dan 80% van het RAM, of de test eindigde te vroeg.

    Stop services en voer de test opnieuw uit, of gebruik de LiveCD.

  • STOPPED

    Je hebt een test met een gekozen profiel voor het einde gestopt.

    Laat de test tot het einde lopen om een resultaat te krijgen.

Exitcodes van de hele test, voor scripts: 0 PASSED, 1 harde fouten, 2 alleen transiënte fouten, 3 CRITICAL of PARTIAL.

Twee testruns, opgenomen

Twee testruns van MemHound 0.6.10 op een QNAP NAS, in een terminal van 80 bij 25 tekens. De eerste testrun eindigt met PASSED. In de tweede testrun keert --demo fault met opzet één bit om, en de testrun eindigt met BAD RAM.

./memhound --demo pass --ui280×25
                                                                                                                                                                                                                                                                                                                                                                                                                   ╔═════════════════════ MemHound 0.6.10: the result ══════════════════════╗      ║                                                                        ║      ║            ▄▄▄▄▄▄  ▄▄▄▄▄▄▄ ▄▄▄▄▄▄▄ ▄▄▄▄▄▄▄ ▄▄▄▄▄▄▄ ▄▄▄▄▄▄              ║      ║            ███ ███ ███ ███ ███▄▄▄▄ ███▄▄▄▄ ███ ███ ███ ███             ║      ║            ▓▓▓ █▓█ ▓▓▓▀▓▓▓ ▀▀▀▀▓▓▓ ▀▀▀▀▓▓▓ ▓▓▓▄▀▀▀ ▓▓▓ ▓▓▓             ║      ║            ▒▒▒▀▀▀  ▒▒▒ ▒▒▒ ▒▒▒ ▒▒▒ ▒▒▒ ▒▒▒ ▒▒▒ ▄▄▄ ▒▒▒ ▒▒▒             ║      ║            ░░░     ░░░ ░░░ ░░░ ░░░ ░░░ ░░░ ░░░ ░░░ ░░░ ░░░             ║      ║            ▀▀▀     ▀▀▀ ▀▀▀ ▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀ ▀▀▀▀▀▀              ║      ║                                                                        ║      ║                   No faults found. Tested 12.75GiB.                    ║      ║         Demo run (--demo pass): 10 seconds of the Quick test.          ║      ║                                                                        ║      ║         Press Enter, Space, Esc or Q to see the full summary.          ║      ╚════════════════════════════════════════════════════════════════════════╝                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   
Opgenomen op 2026-11-16 met het echte programma. De demo test 256 MB gedurende 10 seconden. Een echte test duurt langer. Lettertype: IBM VGA 8x16 uit The Ultimate Oldschool PC Font Pack van VileR, CC BY-SA 4.0. int10h.org · LICENSE-oldschool-pc-fonts.txt

Via SSH uitvoeren

Meld je via SSH als beheerder aan op de NAS en voer deze commando’s uit. Het archief bevat het programma voor drie processortypes. De commando’s kiezen het programma voor jouw NAS.

# op de NAS, via SSH
arch=$(uname -m)
# uname meldt armv7l; het programma heet armhf
[ "$arch" = armv7l ] && arch=armhf
wget https://qnaputilities.com/pub/memhound/bin/memhound.tar.gz
tar zxvf memhound.tar.gz
chmod +x memhound*
./memhound-$arch

MemHound installeert niets. Om het te verwijderen, wis je de bestanden.

Veelgebruikte commando’s

./memhound-$arch
De hele test: Quick, daarna Extended-rondes tot je op q drukt.
./memhound-$arch --passes 2
Hetzelfde, en de test stopt vanzelf na 2 Extended-rondes.
./memhound-$arch --quick
Eén Quick-ronde.
./memhound-$arch --full
Test bijna al het vrije geheugen in één testrun. Gebruik dit als de NAS inactief is.
./memhound-$arch --report /tmp/memhound.txt
Schrijft de samenvatting ook naar een tekstbestand.
./memhound-$arch --bench --ui2
Meet de snelheid en latentie van het geheugen. Zoekt niet naar fouten.
./memhound-$arch --demo pass --ui2
Een demorun van 10 seconden die eindigt met PASSED. --demo fault eindigt met BAD RAM.
./memhound-$arch --help
Toont alle opties.

Downloaden

Het programma voor x86_64, aarch64 en armhf, en de LiveCD voor pc’s en x86-NAS-modellen.

Bijna al het geheugen testen: de LiveCD

Op een draaiende NAS gebruiken QTS en zijn apps een deel van het geheugen, en MemHound kan dat deel niet testen. De LiveCD start een klein Linux-systeem met alleen MemHound erin, zodat de test bijna al het RAM bereikt.

Hij start op pc’s en x86-NAS-modellen met een HDMI-poort. Een ARM-NAS kan hem niet starten. Als Secure Boot aan staat, zet het dan eerst uit.

  1. Schrijf het ISO-image met balenaEtcher, Rufus of dd naar een USB-stick, of brand het op een cd.
  2. Sluit een monitor en een USB-toetsenbord aan en start de computer vanaf de stick.
  3. Druk op 1 om de test te starten. Als je geen toets indrukt, start de test na 15 seconden vanzelf, en een foutloos resultaat herstart de computer 60 seconden later.
  4. Lees het rapport in de map memhound op de stick. Op een stick die volledig is beschreven, staat het op de partitie MHDATA. Als het geheugen slecht is, blijft het resultaat op het scherm en stopt de computer.

Grenzen

  • Op een draaiende NAS test MemHound alleen het vrije geheugen. Als het minder dan 80% van het RAM bereikt, is het resultaat PARTIAL. De LiveCD bereikt bijna al het RAM.
  • MemHound draait als een normaal programma, dus de test gebruikt ook de processor, zijn cache en de geheugencontroller. Een fout laat zien dat deze keten faalde. Harde fouten op vaste fysieke adressen wijzen op een geheugenmodule.
  • Fysieke adressen vereisen het root-account. Zonder dat account toont MemHound een logische kaart.
  • MemHound noemt de sleuf van een fout alleen als het systeem EDAC-labels voor zijn modules heeft.
  • --demo fault keert met opzet een bit om. Zijn BAD RAM is geen testresultaat.

Gerelateerde pagina’s

Deze pagina als Markdown: memhound-nl.md.