Unofficial

MemHound: ett RAM-test för en NAS i drift

Ett enda statiskt program testar det lediga minnet i en QNAP NAS via SSH. LiveCD:n testar nästan hela minnet i en PC eller en x86-NAS.

MemHound tar det lediga minnet i block om 128 MB. Det låser varje block i RAM, skriver testmönster i det och läser tillbaka dem. För varje felaktigt ord visar det den fysiska adressen.

NAS:en fortsätter att leverera filer under testet. MemHound håller 256 MB minne ledigt och kör med lägsta prioritet. Om minnet tar slut stoppar systemet MemHound före alla andra program.

Version 0.6.10 · x86_64, aarch64 och armhf · QTS och QuTS hero · freeware

  • 128MB i varje block som MemHound låser och testar
  • 256MB minne som alltid förblir ledigt för NAS:en
  • 21tester på varje block i en Extended-genomgång

Så går ett test till

Utan flaggor kör MemHound hela RAM-testet i fyra steg. Steg 3 upprepas tills du trycker på q.

  1. Frigöra minnet

    MemHound skriver cachen till disk och släpper den. På QuTS hero tömmer det även ZFS ARC. Testet kan då använda mer minne.

    sync, drop_caches, zinject -a
  2. Quick-genomgång

    Tre tester på varje block: adresstestet, ett schackrutemönster och rörliga inversioner med slumpvärden.

    86 ms för varje block på 128 MB
  3. Extended-genomgångar

    21 tester på varje block. Före varje genomgång frigör MemHound minnet igen. Genomgångarna upprepas tills du trycker på q eller MemHound hittar ett fel.

    5,3 s för varje block på 128 MB
  4. Resultatet

    Ett stort ord visar resultatet. Under det står två rader: vad MemHound hittade och vad du gör härnäst. Sedan kommer den fullständiga sammanfattningen.

    Tested X MB of Y MB (Z%)

Inuti en genomgång: ett block i taget

En genomgång håller inte allt ledigt minne på samma gång. Den testar ett block och släpper det sedan:

  1. MemHound tar 128 MB ledigt minne och låser det med mlock. Systemet kan då inte flytta det till swap.
  2. Det kör adresstestet först. Om det testet misslyckas markerar MemHound alla andra resultat som osäkra.
  3. Det kör mönstertesterna. Varje test skriver hela blocket, trycker ut det ur processorns cache och läser sedan tillbaka det.
  4. Det släpper blocket och tar nästa. Före varje block kontrollerar det att 256 MB förblir ledigt.

Om ett ord läses tillbaka fel läser MemHound det igen upp till 8 gånger och sparar dess fysiska adress. Ett fel som upprepas på samma adress är ett bestående fel. Ett fel som inte upprepas är ett övergående fel.

De 21 testerna i en Extended-genomgång

Tiden för varje test på ett block på 128 MB. Vi mätte den med MemHound 0.6.10 på en QNAP NAS med en Intel Core i5-1235U och 16 GB RAM. Peka på en stapel för att se vad testet skriver.

Ett block på 128 MB, alla tester

  • Quick-genomgång86 ms
  • Extended-genomgång5 337 ms
  • Adresstest, först i varje genomgång
  • Även i Quick-genomgången
  • Standardtester
  • Jämförelsetester
  • stuck-addr14 msSkriver varje ords adress i ordet och läser sedan tillbaka varje ord.
  • solid013 msSkriver alla bitar 0 och läser sedan tillbaka dem.
  • solid114 msSkriver alla bitar 1 och läser sedan tillbaka dem.
  • checker24 msSkriver omväxlande bitar 0 och 1, sedan det omvända mönstret.
  • movinv028 msRörliga inversioner: fyller med 0, läser sedan och inverterar varje ord, först uppåt, sedan nedåt.
  • movinv126 msSamma rörliga inversioner, med start från alla bitar 1.
  • movinv-rand31 msRörliga inversioner med slumpvärden som ett frö kan upprepa.
  • modulo20250 msSkriver ett värde i vart 20:e ord och dess invers i alla andra ord, 20 gånger.
  • walk1 590 msFlyttar en enda 1-bit genom varje position i ordet, sedan en enda 0-bit.
  • movinv8206 msRörliga inversioner med 8 bytemönster, med en satt bit i varje.
  • blockseq209 msFyller blocket med 16 bytevärden (00, 55, AA, FF och andra) och läser tillbaka vart och ett.
  • bitflip1 626 msVäxlar mellan ett ord med en satt bit och ett ord där bara den biten är nollställd, för var och en av de 64 bitarna.
  • bitspread805 msSamma sak med två intilliggande bitar, för varje intilliggande par av de 64 bitarna.
  • rand-dual71 msSkriver samma slumpvärden i blockets båda halvor och jämför halvorna.
  • cmp-xor58 msBåda halvorna får slumpvärden som kombinerats med ett och samma tal genom XOR, sedan jämför MemHound dem.
  • cmp-sub58 msSamma jämförelse, med subtraktion.
  • cmp-mul58 msSamma jämförelse, med multiplikation.
  • cmp-div66 msSamma jämförelse, med division.
  • cmp-or58 msSamma jämförelse, med OR.
  • cmp-and57 msSamma jämförelse, med AND.
  • seqinc75 msSamma jämförelse, med värden som ökar från ord till ord.
De flesta tester tar under 0,1 s. walk och bitflip tar 1,6 s vardera eftersom de flyttar en bit genom varje position i ett 64-bitarsord.
Visa siffrorna som en tabell
TestGruppmsVad det gör
stuck-addrAdresstest, först i varje genomgång14Skriver varje ords adress i ordet och läser sedan tillbaka varje ord.
solid0Standardtester13Skriver alla bitar 0 och läser sedan tillbaka dem.
solid1Standardtester14Skriver alla bitar 1 och läser sedan tillbaka dem.
checkerÄven i Quick-genomgången24Skriver omväxlande bitar 0 och 1, sedan det omvända mönstret.
movinv0Standardtester28Rörliga inversioner: fyller med 0, läser sedan och inverterar varje ord, först uppåt, sedan nedåt.
movinv1Standardtester26Samma rörliga inversioner, med start från alla bitar 1.
movinv-randÄven i Quick-genomgången31Rörliga inversioner med slumpvärden som ett frö kan upprepa.
modulo20Standardtester250Skriver ett värde i vart 20:e ord och dess invers i alla andra ord, 20 gånger.
walkStandardtester1 590Flyttar en enda 1-bit genom varje position i ordet, sedan en enda 0-bit.
movinv8Standardtester206Rörliga inversioner med 8 bytemönster, med en satt bit i varje.
blockseqStandardtester209Fyller blocket med 16 bytevärden (00, 55, AA, FF och andra) och läser tillbaka vart och ett.
bitflipStandardtester1 626Växlar mellan ett ord med en satt bit och ett ord där bara den biten är nollställd, för var och en av de 64 bitarna.
bitspreadStandardtester805Samma sak med två intilliggande bitar, för varje intilliggande par av de 64 bitarna.
rand-dualStandardtester71Skriver samma slumpvärden i blockets båda halvor och jämför halvorna.
cmp-xorJämförelsetester58Båda halvorna får slumpvärden som kombinerats med ett och samma tal genom XOR, sedan jämför MemHound dem.
cmp-subJämförelsetester58Samma jämförelse, med subtraktion.
cmp-mulJämförelsetester58Samma jämförelse, med multiplikation.
cmp-divJämförelsetester66Samma jämförelse, med division.
cmp-orJämförelsetester58Samma jämförelse, med OR.
cmp-andJämförelsetester57Samma jämförelse, med AND.
seqincJämförelsetester75Samma jämförelse, med värden som ökar från ord till ord.

Adresstestet

En minnesmodul hittar ett ord via dess adress. Om en adressledning är trasig leder två adresser till samma cell. Då kan ett mönstertest skriva och läsa samma felaktiga cell utan att se något fel.

Därför körs adresstestet först, på varje block. Det skriver varje ords adress i ordet. Sedan läser det tillbaka varje ord. Ett ord som innehåller ett annat ords adress visar en trasig adressledning.

Om adresstestet misslyckas blir resultatet CRITICAL: de andra testerna i den körningen kan inte bevisa något.

En felfri modul

AdressSkrivetTillbakaläst
100010001000
100810081008
101010101010
101810181018
102010201020
102810281028
103010301030
103810381038

Adressledning 5 fastlåst på 0

AdressSkrivetTillbakaläst
100010001020
100810081028
101010101030
101810181038
102010201020
102810281028
103010301030
103810381038
När ledning 5 är fastlåst hamnar skrivningarna till 1020 upp till 1038 i cellerna för 1000 upp till 1018. De fyra första orden läser då tillbaka fel adresser.

Vad varje resultat betyder

I slutet av ett test som du själv har startat visar MemHound ett av sex ord med stora bokstäver. Ett test från appen StorageDiag, USB-avbildningen eller LiveCD:ns nedräkning visar inte den här skärmen.

  • PASSED

    Inga fel. Under hela testet nådde MemHound också minst 80 % av RAM-minnet.

    Minnet är felfritt.

  • BAD RAM

    Bestående fel: ett fel upprepas på samma adress.

    Misstänk minnesmodulen. Sammanfattningen listar adresserna.

  • CRITICAL

    Adresstestet misslyckades: vissa adresser tappar sina data.

    Misstänk minnesmodulen eller minneskontrollern.

  • FAILED

    Endast övergående fel: de upprepades inte på samma adress.

    Strömförsörjning, värme eller minnets timing kan orsaka dem. Kör testet igen.

  • PARTIAL

    Inga fel, men MemHound testade mindre än 80 % av RAM-minnet, eller så slutade testet i förtid.

    Stoppa tjänster och kör testet igen, eller använd LiveCD:n.

  • STOPPED

    Du stoppade ett test med en vald profil innan det var klart.

    Kör testet till slutet för att få ett resultat.

Slutkoder för hela testet, för skript: 0 PASSED, 1 bestående fel, 2 endast övergående fel, 3 CRITICAL eller PARTIAL.

Två testkörningar, inspelade

Två körningar av MemHound 0.6.10 på en QNAP NAS, i en terminal på 80 gånger 25 tecken. Den första körningen slutar med PASSED. I den andra körningen vänder --demo fault avsiktligt en bit, och körningen slutar med 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.          ║      ╚════════════════════════════════════════════════════════════════════════╝                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   
Inspelat 2026-11-16 från det riktiga programmet. Demon testar 256 MB i 10 sekunder. Ett riktigt test tar längre tid. Typsnitt: IBM VGA 8x16 från The Ultimate Oldschool PC Font Pack av VileR, CC BY-SA 4.0. int10h.org · LICENSE-oldschool-pc-fonts.txt

Kör det via SSH

Logga in på NAS:en via SSH som administratör och kör de här kommandona. Arkivet innehåller programmet för tre processortyper. Kommandona väljer det som passar din NAS.

# på NAS:en, via SSH
arch=$(uname -m)
# uname visar armv7l; programmet heter 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 installerar ingenting. Om du vill ta bort det raderar du filerna.

Vanliga kommandon

./memhound-$arch
Hela testet: Quick, sedan Extended-genomgångar tills du trycker på q.
./memhound-$arch --passes 2
Samma sak, och testet stoppar av sig självt efter 2 Extended-genomgångar.
./memhound-$arch --quick
En Quick-genomgång.
./memhound-$arch --full
Testar nästan allt ledigt minne i en enda körning. Använd det när NAS:en är inaktiv.
./memhound-$arch --report /tmp/memhound.txt
Skriver även sammanfattningen till en textfil.
./memhound-$arch --bench --ui2
Mäter minnets hastighet och latens. Det letar inte efter fel.
./memhound-$arch --demo pass --ui2
En demokörning på 10 sekunder som slutar med PASSED. --demo fault slutar med BAD RAM.
./memhound-$arch --help
Visar alla flaggor.

Ladda ner

Programmet för x86_64, aarch64 och armhf, och LiveCD:n för PC och x86-NAS-modeller.

Testa nästan hela minnet: LiveCD:n

På en NAS i drift använder QTS och dess appar en del av minnet, och MemHound kan inte testa den delen. LiveCD:n startar ett litet Linux-system med bara MemHound i, så testet når nästan hela RAM-minnet.

Den startar på PC och x86-NAS-modeller med HDMI-port. En ARM-NAS kan inte starta den. Om Secure Boot är på stänger du först av det.

  1. Skriv ISO-avbildningen till ett USB-minne med balenaEtcher, Rufus eller dd, eller bränn den på en CD.
  2. Anslut en bildskärm och ett USB-tangentbord och starta sedan datorn från USB-minnet.
  3. Tryck på 1 för att starta testet. Om du inte trycker på någon tangent startar testet av sig självt efter 15 sekunder, och ett felfritt resultat startar om datorn 60 sekunder senare.
  4. Läs rapporten i mappen memhound på USB-minnet. På ett USB-minne som skrivits i sin helhet finns den på partitionen MHDATA. Om minnet är trasigt ligger resultatet kvar på skärmen och datorn stannar.

Begränsningar

  • På en NAS i drift testar MemHound bara det lediga minnet. Om det når mindre än 80 % av RAM-minnet blir resultatet PARTIAL. LiveCD:n når nästan hela RAM-minnet.
  • MemHound körs som ett vanligt program, så testet använder också processorn, dess cache och minneskontrollern. Ett fel visar att den här kedjan fallerade. Bestående fel på fasta fysiska adresser pekar på en minnesmodul.
  • Fysiska adresser kräver kontot root. Utan det kontot visar MemHound en logisk karta.
  • MemHound anger kortplatsen för ett fel bara om systemet har EDAC-etiketter för sina moduler.
  • --demo fault vänder avsiktligt en bit. Dess BAD RAM är inget testresultat.

Relaterade sidor

Den här sidan som Markdown: memhound-sv.md.