Unofficial

MemHound : un test de la RAM pour un NAS en fonctionnement

Un seul programme statique teste par SSH la mémoire libre d’un NAS QNAP. Le LiveCD teste presque toute la mémoire d’un PC ou d’un NAS x86.

MemHound prend la mémoire libre par blocs de 128 Mo. Il verrouille chaque bloc en RAM, y écrit des motifs de test et les relit. Pour chaque mot défectueux, il affiche l’adresse physique.

Le NAS continue de servir les fichiers pendant le test. MemHound laisse 256 Mo de mémoire libres et tourne à la priorité la plus basse. Si la mémoire vient à manquer, le système arrête MemHound avant tout autre programme.

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

  • 128Mo dans chaque bloc que MemHound verrouille et teste
  • 256Mo de mémoire qui restent toujours libres pour le NAS
  • 21tests sur chaque bloc dans une passe Extended

Déroulement d’un test

Sans option, MemHound exécute le test complet de la RAM en quatre étapes. L’étape 3 se répète jusqu’à ce que vous appuyiez sur q.

  1. Libérer la mémoire

    MemHound écrit le cache sur le disque et le vide. Sous QuTS hero, il vide aussi le ZFS ARC. Le test peut alors utiliser plus de mémoire.

    sync, drop_caches, zinject -a
  2. Passe Quick

    Trois tests sur chaque bloc : le test des adresses, un damier et des inversions mobiles avec des valeurs aléatoires.

    86 ms pour chaque bloc de 128 Mo
  3. Passes Extended

    21 tests sur chaque bloc. Avant chaque passe, MemHound libère de nouveau la mémoire. Les passes se répètent jusqu’à ce que vous appuyiez sur q ou que MemHound trouve une erreur.

    5,3 s pour chaque bloc de 128 Mo
  4. Le résultat

    Un grand mot affiche le résultat. En dessous, deux lignes indiquent ce que MemHound a trouvé et ce qu’il faut faire ensuite. Le résumé complet suit.

    Tested X MB of Y MB (Z%)

Dans une passe : un bloc à la fois

Une passe n’occupe pas toute la mémoire libre en même temps. Elle teste un bloc, puis le libère :

  1. MemHound prend 128 Mo de mémoire libre et les verrouille avec mlock. Le système ne peut alors pas les déplacer vers le swap.
  2. Il exécute d’abord le test des adresses. Si ce test échoue, MemHound marque tous les autres résultats comme incertains.
  3. Il exécute les tests de motifs. Chaque test écrit tout le bloc, le chasse du cache du processeur, puis le relit.
  4. Il libère le bloc et prend le suivant. Avant chaque bloc, il vérifie que 256 Mo restent libres.

Si un mot est relu de façon incorrecte, MemHound le relit jusqu’à 8 fois et note son adresse physique. Une erreur qui se répète à la même adresse est une erreur persistante. Une erreur qui ne se répète pas est une erreur transitoire.

Les 21 tests d’une passe Extended

La durée de chaque test sur un bloc de 128 Mo. Nous l’avons mesurée avec MemHound 0.6.10 sur un NAS QNAP doté d’un Intel Core i5-1235U et de 16 Go de RAM. Pointez une barre pour voir ce que le test écrit.

Un bloc de 128 Mo, tous les tests

  • Passe Quick86 ms
  • Passe Extended5 337 ms
  • Test des adresses, le premier de chaque passe
  • Aussi dans la passe Quick
  • Tests standard
  • Tests de comparaison
  • stuck-addr14 msÉcrit l’adresse de chaque mot dans le mot, puis relit chaque mot.
  • solid013 msÉcrit tous les bits à 0, puis les relit.
  • solid114 msÉcrit tous les bits à 1, puis les relit.
  • checker24 msÉcrit des bits 0 et 1 en alternance, puis le motif inverse.
  • movinv028 msInversions mobiles : remplit de 0, puis lit et inverse chaque mot, d’abord vers le haut, puis vers le bas.
  • movinv126 msLes mêmes inversions mobiles, en partant de tous les bits à 1.
  • movinv-rand31 msInversions mobiles avec des valeurs aléatoires qu’une graine permet de reproduire.
  • modulo20250 msÉcrit une valeur dans un mot sur 20 et son inverse dans tous les autres mots, 20 fois.
  • walk1 590 msDéplace un seul bit 1 à travers chaque position du mot, puis un seul bit 0.
  • movinv8206 msInversions mobiles avec 8 motifs d’octet, un bit positionné dans chacun.
  • blockseq209 msRemplit le bloc avec 16 valeurs d’octet (00, 55, AA, FF et d’autres) et relit chacune.
  • bitflip1 626 msAlterne un mot avec un seul bit positionné et un mot où seul ce bit est effacé, pour chacun des 64 bits.
  • bitspread805 msLa même chose avec deux bits adjacents, pour chaque paire adjacente des 64 bits.
  • rand-dual71 msÉcrit les mêmes valeurs aléatoires dans les deux moitiés du bloc et compare les moitiés.
  • cmp-xor58 msLes deux moitiés reçoivent des valeurs aléatoires combinées à un même nombre par XOR, puis MemHound les compare.
  • cmp-sub58 msLa même comparaison, avec une soustraction.
  • cmp-mul58 msLa même comparaison, avec une multiplication.
  • cmp-div66 msLa même comparaison, avec une division.
  • cmp-or58 msLa même comparaison, avec OR.
  • cmp-and57 msLa même comparaison, avec AND.
  • seqinc75 msLa même comparaison, avec des valeurs qui augmentent d’un mot à l’autre.
La plupart des tests durent moins de 0,1 s. walk et bitflip durent 1,6 s chacun, car ils déplacent un bit à travers chaque position d’un mot de 64 bits.
Afficher les nombres sous forme de tableau
TestGroupemsCe qu’il fait
stuck-addrTest des adresses, le premier de chaque passe14Écrit l’adresse de chaque mot dans le mot, puis relit chaque mot.
solid0Tests standard13Écrit tous les bits à 0, puis les relit.
solid1Tests standard14Écrit tous les bits à 1, puis les relit.
checkerAussi dans la passe Quick24Écrit des bits 0 et 1 en alternance, puis le motif inverse.
movinv0Tests standard28Inversions mobiles : remplit de 0, puis lit et inverse chaque mot, d’abord vers le haut, puis vers le bas.
movinv1Tests standard26Les mêmes inversions mobiles, en partant de tous les bits à 1.
movinv-randAussi dans la passe Quick31Inversions mobiles avec des valeurs aléatoires qu’une graine permet de reproduire.
modulo20Tests standard250Écrit une valeur dans un mot sur 20 et son inverse dans tous les autres mots, 20 fois.
walkTests standard1 590Déplace un seul bit 1 à travers chaque position du mot, puis un seul bit 0.
movinv8Tests standard206Inversions mobiles avec 8 motifs d’octet, un bit positionné dans chacun.
blockseqTests standard209Remplit le bloc avec 16 valeurs d’octet (00, 55, AA, FF et d’autres) et relit chacune.
bitflipTests standard1 626Alterne un mot avec un seul bit positionné et un mot où seul ce bit est effacé, pour chacun des 64 bits.
bitspreadTests standard805La même chose avec deux bits adjacents, pour chaque paire adjacente des 64 bits.
rand-dualTests standard71Écrit les mêmes valeurs aléatoires dans les deux moitiés du bloc et compare les moitiés.
cmp-xorTests de comparaison58Les deux moitiés reçoivent des valeurs aléatoires combinées à un même nombre par XOR, puis MemHound les compare.
cmp-subTests de comparaison58La même comparaison, avec une soustraction.
cmp-mulTests de comparaison58La même comparaison, avec une multiplication.
cmp-divTests de comparaison66La même comparaison, avec une division.
cmp-orTests de comparaison58La même comparaison, avec OR.
cmp-andTests de comparaison57La même comparaison, avec AND.
seqincTests de comparaison75La même comparaison, avec des valeurs qui augmentent d’un mot à l’autre.

Le test des adresses

Un module de mémoire trouve un mot par son adresse. Si une ligne d’adresse est défectueuse, deux adresses mènent à la même cellule. Un test de motifs peut alors écrire et lire la même mauvaise cellule sans voir d’erreur.

C’est pourquoi le test des adresses s’exécute en premier, sur chaque bloc. Il écrit l’adresse de chaque mot dans le mot. Puis il relit chaque mot. Un mot qui contient l’adresse d’un autre mot révèle une ligne d’adresse défectueuse.

Si le test des adresses échoue, le résultat est CRITICAL : les autres tests de cette exécution ne peuvent rien prouver.

Un module sain

AdresseÉcritRelu
100010001000
100810081008
101010101010
101810181018
102010201020
102810281028
103010301030
103810381038

Ligne d’adresse 5 bloquée à 0

AdresseÉcritRelu
100010001020
100810081028
101010101030
101810181038
102010201020
102810281028
103010301030
103810381038
Avec la ligne 5 bloquée, les écritures vers 1020 à 1038 aboutissent dans les cellules de 1000 à 1018. Les quatre premiers mots renvoient alors les mauvaises adresses.

Ce que signifie chaque résultat

À la fin d’un test que vous avez lancé vous-même, MemHound affiche l’un de six mots en grandes lettres. Un test lancé depuis l’application StorageDiag, l’image USB ou le compte à rebours du LiveCD n’affiche pas cet écran.

  • PASSED

    Aucune erreur. Sur l’ensemble du test, MemHound a aussi atteint au moins 80 % de la RAM.

    La mémoire est en bon état.

  • BAD RAM

    Erreurs persistantes : une erreur se répète à la même adresse.

    Le module de mémoire est suspect. Le résumé liste les adresses.

  • CRITICAL

    Le test des adresses a échoué : certaines adresses perdent leurs données.

    Le module de mémoire ou le contrôleur mémoire est suspect.

  • FAILED

    Erreurs transitoires uniquement : elles ne se sont pas répétées à la même adresse.

    L’alimentation, la chaleur ou les timings de la mémoire peuvent les causer. Relancez le test.

  • PARTIAL

    Aucune erreur, mais MemHound a testé moins de 80 % de la RAM, ou le test s’est arrêté plus tôt.

    Arrêtez des services et relancez le test, ou utilisez le LiveCD.

  • STOPPED

    Vous avez arrêté un test avec un profil choisi avant sa fin.

    Laissez le test aller jusqu’à sa fin pour obtenir un résultat.

Codes de sortie du test complet, pour les scripts : 0 PASSED, 1 erreurs persistantes, 2 erreurs transitoires uniquement, 3 CRITICAL ou PARTIAL.

Deux exécutions du test, enregistrées

Deux exécutions de MemHound 0.6.10 sur un NAS QNAP, dans un terminal de 80 sur 25 caractères. La première se termine par PASSED. Dans la seconde, --demo fault inverse volontairement un bit, et l’exécution se termine par 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.          ║      ╚════════════════════════════════════════════════════════════════════════╝                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   
Enregistré le 2026-11-16 à partir du vrai programme. La démo teste 256 Mo pendant 10 secondes. Un vrai test dure plus longtemps. Police : IBM VGA 8x16 de The Ultimate Oldschool PC Font Pack par VileR, CC BY-SA 4.0. int10h.org · LICENSE-oldschool-pc-fonts.txt

Le lancer par SSH

Connectez-vous au NAS par SSH en tant qu’administrateur et exécutez ces commandes. L’archive contient le programme pour trois types de processeur. Les commandes choisissent celui de votre NAS.

# sur le NAS, par SSH
arch=$(uname -m)
# uname indique armv7l ; le programme s’appelle 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 n’installe rien. Pour le supprimer, effacez les fichiers.

Commandes courantes

./memhound-$arch
Le test complet : Quick, puis des passes Extended jusqu’à ce que vous appuyiez sur q.
./memhound-$arch --passes 2
La même chose, et le test s’arrête de lui-même après 2 passes Extended.
./memhound-$arch --quick
Une passe Quick.
./memhound-$arch --full
Teste presque toute la mémoire libre en une seule exécution. Utilisez-le quand le NAS est inactif.
./memhound-$arch --report /tmp/memhound.txt
Écrit aussi le résumé dans un fichier texte.
./memhound-$arch --bench --ui2
Mesure la vitesse et la latence de la mémoire. Ne cherche aucune erreur.
./memhound-$arch --demo pass --ui2
Une exécution de démonstration de 10 secondes qui se termine par PASSED. --demo fault se termine par BAD RAM.
./memhound-$arch --help
Affiche toutes les options.

Téléchargement

Le programme pour x86_64, aarch64 et armhf, et le LiveCD pour les PC et les modèles de NAS x86.

Tester presque toute la mémoire : le LiveCD

Sur un NAS en fonctionnement, QTS et ses applications utilisent une partie de la mémoire, et MemHound ne peut pas tester cette partie. Le LiveCD démarre un petit système Linux qui ne contient que MemHound, si bien que le test atteint presque toute la RAM.

Il démarre sur les PC et les modèles de NAS x86 dotés d’un port HDMI. Un NAS ARM ne peut pas le démarrer. Si Secure Boot est activé, désactivez-le d’abord.

  1. Écrivez l’image ISO sur une clé USB avec balenaEtcher, Rufus ou dd, ou gravez-la sur un CD.
  2. Branchez un écran et un clavier USB, puis démarrez l’ordinateur depuis la clé.
  3. Appuyez sur 1 pour lancer le test. Si vous n’appuyez sur aucune touche, le test démarre de lui-même après 15 secondes, et un résultat sans erreur redémarre l’ordinateur 60 secondes plus tard.
  4. Lisez le rapport dans le dossier memhound de la clé. Sur une clé écrite en entier, il se trouve sur la partition MHDATA. Si la mémoire est défectueuse, le résultat reste à l’écran et l’ordinateur s’arrête.

Limites

  • Sur un NAS en fonctionnement, MemHound teste seulement la mémoire libre. S’il atteint moins de 80 % de la RAM, le résultat est PARTIAL. Le LiveCD en atteint presque la totalité.
  • MemHound tourne comme un programme normal, donc le test utilise aussi le processeur, son cache et le contrôleur mémoire. Une erreur montre que cette chaîne a échoué. Des erreurs persistantes à des adresses physiques fixes désignent un module de mémoire.
  • Les adresses physiques demandent le compte root. Sans lui, MemHound affiche une carte logique.
  • MemHound nomme l’emplacement d’une erreur seulement si le système dispose d’étiquettes EDAC pour ses modules.
  • --demo fault inverse volontairement un bit. Son BAD RAM n’est pas un résultat de test.

Pages associées

Cette page en Markdown : memhound-fr.md.