# 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. https://www.qnaputilities.com/memhound-fr.html

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

| Test | Groupe | ms | Ce qu’il fait |
|---|---|--:|---|
| `stuck-addr` | Test des adresses, le premier de chaque passe | 14 | Écrit l’adresse de chaque mot dans le mot, puis relit chaque mot. |
| `solid0` | Tests standard | 13 | Écrit tous les bits à 0, puis les relit. |
| `solid1` | Tests standard | 14 | Écrit tous les bits à 1, puis les relit. |
| `checker` | Aussi dans la passe Quick | 24 | Écrit des bits 0 et 1 en alternance, puis le motif inverse. |
| `movinv0` | Tests standard | 28 | Inversions mobiles : remplit de 0, puis lit et inverse chaque mot, d’abord vers le haut, puis vers le bas. |
| `movinv1` | Tests standard | 26 | Les mêmes inversions mobiles, en partant de tous les bits à 1. |
| `movinv-rand` | Aussi dans la passe Quick | 31 | Inversions mobiles avec des valeurs aléatoires qu’une graine permet de reproduire. |
| `modulo20` | Tests standard | 250 | Écrit une valeur dans un mot sur 20 et son inverse dans tous les autres mots, 20 fois. |
| `walk` | Tests standard | 1590 | Déplace un seul bit 1 à travers chaque position du mot, puis un seul bit 0. |
| `movinv8` | Tests standard | 206 | Inversions mobiles avec 8 motifs d’octet, un bit positionné dans chacun. |
| `blockseq` | Tests standard | 209 | Remplit le bloc avec 16 valeurs d’octet (00, 55, AA, FF et d’autres) et relit chacune. |
| `bitflip` | Tests standard | 1626 | Alterne un mot avec un seul bit positionné et un mot où seul ce bit est effacé, pour chacun des 64 bits. |
| `bitspread` | Tests standard | 805 | La même chose avec deux bits adjacents, pour chaque paire adjacente des 64 bits. |
| `rand-dual` | Tests standard | 71 | Écrit les mêmes valeurs aléatoires dans les deux moitiés du bloc et compare les moitiés. |
| `cmp-xor` | Tests de comparaison | 58 | Les deux moitiés reçoivent des valeurs aléatoires combinées à un même nombre par XOR, puis MemHound les compare. |
| `cmp-sub` | Tests de comparaison | 58 | La même comparaison, avec une soustraction. |
| `cmp-mul` | Tests de comparaison | 58 | La même comparaison, avec une multiplication. |
| `cmp-div` | Tests de comparaison | 66 | La même comparaison, avec une division. |
| `cmp-or` | Tests de comparaison | 58 | La même comparaison, avec OR. |
| `cmp-and` | Tests de comparaison | 57 | La même comparaison, avec AND. |
| `seqinc` | Tests de comparaison | 75 | La même comparaison, avec des valeurs qui augmentent d’un mot à l’autre. |

Passe Quick: 86 ms. Passe Extended: 5337 ms. 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.

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

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.

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

```sh
# 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.

- [memhound.tar.gz](https://www.qnaputilities.com/pub/memhound/bin/memhound.tar.gz): Le programme pour 3 types de processeur, dans une seule archive
- [pub/memhound/bin/](https://www.qnaputilities.com/pub/memhound/bin/): Chaque fichier du programme séparément
- [memhound-livecd-0.6.10.iso](https://www.qnaputilities.com/pub/memhound/livecd/memhound-livecd-0.6.10.iso): LiveCD 0.6.10, image ISO, 57 Mo
- [memhound-livecd-0.6.10.iso.sha256](https://www.qnaputilities.com/pub/memhound/livecd/memhound-livecd-0.6.10.iso.sha256): SHA-256 de l’image du LiveCD
- [pub/memhound/livecd/source/](https://www.qnaputilities.com/pub/memhound/livecd/source/): Le code source des parties GPL du LiveCD

### 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

- [Guide : tester la RAM d’un NAS QNAP avec MemHound](https://www.qnaputilities.com/howto-memhound-ram-fr.html)
- [Guide : mesurer la vitesse de la mémoire d’un NAS](https://www.qnaputilities.com/howto-ram-benchmark-fr.html)
- [StorageDiag, l’application qui lance MemHound dans une fenêtre](https://www.qnaputilities.com/storagediag-fr.html)
- [MemHound dans l’App Center](https://www.qnaputilities.com/appcenter.html#memhound)
- [Code source et licences du site](https://www.qnaputilities.com/sources.html)
