Comment interpréter les statistiques d'une exécution de memtest?
J'ai ici un cahier que je soupçonne d'avoir un module de mémoire défectueux. J'ai donc téléchargé Memtest86 + et le laisse fonctionner.
Notez que la capture d'écran n'est pas la mienne, elle est fournie par memtest86 +
Comment interpréter les chiffres à l'écran? Je l'ai laissé fonctionner pendant environ quatre heures et je suis maintenant dans le passage 7.
Surtout que fait
- le numéro de test
- le nombre d'erreurs
- le nombre d'erreurs ECC
indiquer? Quelles sont les valeurs saines pour les erreurs de mémoire? À quel moment devrais-je envisager de remplacer la mémoire?
TL; DR
Le nombre le plus important en premier: Le nombre d'erreurs pour une mémoire saine doit être 0. Tout nombre supérieur à 0 peut indiquer des secteurs endommagés/défectueux.
Explication d'écran
Memtest86+ v1.00 | Progress of the entire pass (test series)
CPU MODEL and clock speed | Progress of individual, current test
Level 1 cache size & speed | Test type that is currently running
Level 2 cache size & speed | Part of the RAM (sector) that is being tested
RAM size and testing speed | Pattern that is being written to the sector
Information about the chipset that your mainboard uses
Information about your RAM set-up, clock speed, channel settings, etc.
WallTime Cached RsvdMem MemMap Cache ECC Test Pass Errors ECC Errs
--------- ------ ------- -------- ----- --- ---- ---- ------ --------
Elapsed Amount Amount Mapping on on Test # of # of # of ECC
time of RAM of used or or type pass errors errors
cached reserved off off done found found
RAM, not
tested
Explication des données/tests
MemTest exécute un certain nombre de tests, écrit des motifs spécifiques dans chaque secteur de la mémoire et les récupère. Si les données récupérées diffèrent des données stockées à l'origine, MemTest enregistre une erreur et augmente le nombre de error de un. Les erreurs sont généralement des signes de mauvaises RAM bandes.
Étant donné que la mémoire n'est pas simplement un bloc-notes contenant des informations, mais également des fonctions avancées telles que la mise en cache, plusieurs tests différents sont effectués. C'est ce que Test # indique. MemTest exécute un certain nombre de tests différents pour voir si des erreurs se produisent.
Quelques exemples de tests (simplifiés):
- Tester les secteurs dans cet ordre: A, B, C, D, E, F. (Série)
- Tester les secteurs dans cet ordre: A, C, E, B, D, F. (Moving)
- Remplir tous les secteurs avec le motif: aaaaaaaa
- Remplissez tous les secteurs avec un motif aléatoire.
Description plus détaillée de tous les tests de: https://www.memtest86.com/technical.htm#detailed
Test 0 [Test d'adresse, marche, pas de cache]
Teste tous les bits d'adresse dans toutes les banques de mémoire en utilisant un modèle d'adresse à distance.
Test 1 [Test d'adresse, adresse propre, séquentielle]
Chaque adresse est écrite avec sa propre adresse, puis sa cohérence est vérifiée. En théorie, les tests précédents auraient dû détecter tout problème d’adressage de la mémoire. Ce test doit détecter toute erreur d’adressage qui n’a pas été détectée d’une manière ou d’une autre. Ce test est effectué séquentiellement avec chaque processeur disponible.
Test 2 [Test d'adresse, adresse propre, Parallèle]
Identique au test 1, mais le test est effectué en parallèle avec toutes les CPU et en utilisant des adresses qui se chevauchent.
Test 3 [Inversions en mouvement, uns et zéros, séquentiels]
Ce test utilise l'algorithme des inversions en mouvement avec des motifs de tous les uns et de zéros. Le cache est activé même s'il interfère dans une certaine mesure avec l'algorithme de test. Avec le cache activé, ce test ne prend pas beaucoup de temps et devrait permettre de trouver rapidement toutes les erreurs "difficiles" et quelques erreurs plus subtiles. Ce test est seulement une vérification rapide. Ce test est effectué séquentiellement avec chaque processeur disponible.
Test 4 [Inversions en mouvement, uns et zéros, Parallèle]
Identique au test 3, mais le test est effectué en parallèle avec tous les processeurs.
Test 5 [Inversions en mouvement, pat bit 8]
Ceci est identique au test 4 mais utilise un motif large de 8 bits de "marche" et de zéros. Ce test détectera mieux les erreurs subtiles dans les puces mémoire "larges".
Test 6 [Inversions en mouvement, motif aléatoire]
Le test 6 utilise le même algorithme que le test 4 mais le motif de données est un nombre aléatoire et complémentaire. Ce test est particulièrement efficace pour détecter les erreurs difficiles à détecter. La séquence de nombres aléatoires étant différente à chaque passage, plusieurs passes en augmentent l'efficacité.
Test 7 [Blocage, 64 déplacements]
Ce test sollicite la mémoire en utilisant des instructions de déplacement de bloc (movsl) et est basé sur le test burnBX de Robert Redelmeier. La mémoire est initialisée avec des motifs de décalage inversés tous les 8 octets. Ensuite, des blocs de mémoire de 4 Mo sont déplacés en utilisant l'instruction movsl. Une fois les déplacements terminés, les modèles de données sont vérifiés. Étant donné que les données ne sont vérifiées qu'une fois les mouvements de mémoire terminés, il est impossible de savoir où l'erreur s'est produite. Les adresses indiquées ne concernent que les endroits où la mauvaise configuration a été trouvée. Étant donné que les déplacements sont limités à un segment de 8 Mo de mémoire, l’adresse défaillante sera toujours à moins de 8 Mo de l’adresse rapportée. Les erreurs de ce test ne sont pas utilisées pour calculer les modèles BadRAM.
Test 8 [Inversions en mouvement, 32 bits pat]
Il s'agit d'une variante de l'algorithme des inversions mobiles qui décale le motif de données d'un bit pour chaque adresse successive. La position du bit de départ est décalée à gauche pour chaque passe. Pour utiliser tous les modèles de données possibles, 32 passes sont requises. Ce test est assez efficace pour détecter les erreurs sensibles aux données, mais le temps d'exécution est long.
Test 9 [Séquence de nombres aléatoires]
Ce test écrit une série de nombres aléatoires dans la mémoire. En réinitialisant le nombre initial pour le nombre aléatoire, la même séquence de nombre peut être créée pour une référence. Le modèle initial est vérifié, puis complété et vérifié à nouveau lors du passage suivant. Cependant, contrairement aux inversions en mouvement, l'écriture et la vérification ne peuvent être effectuées que dans le sens aller.
Test 10 [Modulo 20, uns & zéros]
L’utilisation de l’algorithme Modulo-X devrait permettre de détecter des erreurs qui ne sont pas détectées par des inversions mobiles dues au cache et à l’interférence de mise en mémoire tampon avec l’algorithme. Comme avec test, un seul et des zéros sont utilisés pour les modèles de données.
Test 11 [Test d'atténuation de bit, 90 min, 2 motifs]
Le test de fondu de bit initialise toute la mémoire avec un motif, puis dort pendant 5 minutes. Ensuite, la mémoire est examinée pour voir si des bits de mémoire ont changé. Tous les uns et tous les modèles zéro sont utilisés.
Parce que les secteurs défectueux peuvent parfois fonctionner et ne pas fonctionner une autre fois, je recommande de laisser MemTest exécuter quelques passes. Full pass est une série de tests terminée ayant réussi. (La série de tests ci-dessus 1-11) Plus vous obtiendrez de passes sans erreurs, plus votre exécution de MemTest sera précise. Je cours habituellement autour de 5 passes pour être sûr.
Le nombre d'erreurs pour la mémoire saine doit être 0. Tout nombre supérieur à 0 peut indiquer des secteurs endommagés/défectueux.
Le nombre d'erreurs ECC ne doit être pris en compte que lorsque ECC est défini sur off. ECC est synonyme de mémoire de code de correction d'erreur et c'est un mécanisme pour détecter et corriger les bits erronés dans un état de mémoire. Il peut être comparé légèrement aux contrôles de parité effectués sur un support RAID ou optique. Cette technologie est assez coûteuse et ne sera probablement rencontrée que dans les configurations de serveur. Le compte ECC compte le nombre d'erreurs corrigées par le mécanisme ECC de la mémoire. Il n'est pas nécessaire d'appeler ECC pour une RAM saine, donc un nombre d'erreurs ECC supérieur à 0 peut également indiquer une mémoire insuffisante.
Explication d'erreur
Exemple de Memtest qui a rencontré des erreurs. Il montre quel secteur/adresse a échoué.
La première colonne (Tst) indique quel test a échoué, le numéro correspond au numéro de test de la liste déjà mentionnée ci-dessus. La deuxième colonne (Pass) indique si ce test a a réussi. Dans le cas de l'exemple, le test 7 n'a pas de réussite.
La troisième colonne (Failing Address) indique exactement quelle partie de la mémoire contient des erreurs. Une telle partie a une adresse, très semblable à une adresse IP, qui est unique pour cet élément de stockage de données. Il indique quelle adresse a échoué et quelle est la taille du bloc de données. (0.8MB dans l'exemple)
Les quatrième (Good) et cinquième (Bad) colonnes indiquent les données écrites et ce qui a été récupéré, respectivement. Les deux colonnes doivent être égales dans la mémoire non défectueuse (évidemment).
La sixième colonne (Err-Bits) indique la position exacte des bits défaillants.
La septième colonne (Count) indique le nombre d’erreurs consécutives ayant la même adresse et les mêmes bits.
Enfin, la dernière colonne, Chan, indique le canal (si plusieurs canaux sont utilisés sur le système) dans lequel se trouve la bande mémoire.
S'il trouve des erreurs
Si MemTest détecte des erreurs, la meilleure méthode pour déterminer le module défectueux est traitée dans cette question de super utilisateur et sa réponse acceptée:
Utilisez le processus d'élimination - supprimez la moitié des modules et relancez le test ...
S'il n'y a pas d'échec, alors vous savez que ces deux modules sont bons, alors mettez-les de côté et testez à nouveau.
S'il y a des défaillances, réduisez à nouveau de moitié (maintenant l'un des quatre modules de mémoire), puis testez à nouveau.
Mais, juste parce qu'un test a échoué, ne supposez pas que l'autre échoue (vous pouvez avoir deux modules de mémoire défaillants) - si vous avez détecté une défaillance de deux modules de mémoire, testez chacun de ces deux modules séparément par la suite. .
Remarque importante: avec des fonctionnalités telles que l'entrelacement mémoire et les schémas de numérotation de socket de module de mémoire médiocres de certains fournisseurs de cartes mères, il peut être difficile de savoir quel module est représenté par une adresse donnée.
Numéro de test: numéro du test spécifique en cours d'exécution par memtest. Il y en a beaucoup.
Nombre d'erreurs: le nombre d'erreurs de mémoire rencontrées
Erreurs ECC: Nombre d’erreurs corrigées par ECC. Votre chipset/mémoire n'a pas de code ECC, donc ce nombre n'a pas d'importance.
Si votre mémoire contient un nombre d'erreurs supérieur à 0, vous souhaiterez la remplacer.
EDIT: Les tests sont les différents modèles que memtest écrit en mémoire. Il écrit différents modèles dans la mémoire et les relit pour vérifier les erreurs. Il utilise différents modèles pour pouvoir tester tous les états de tous les bits.
Le compte indique le nombre de fois que le résultat lu dans memtest ne correspond pas à ce qu'il a écrit dans la mémoire, ce qui signifie qu'il y a une erreur dans le bloc de mémoire en cours de test.
ECC est une technologie de correction d'erreur intégrée aux puces de mémoire pour serveurs et stations de travail. La plupart des stations d'arrêt ne prennent pas en charge les modules de mémoire avec ECC intégré. Presque tous les serveurs/stations de travail sont compatibles, et en ont généralement besoin. Le nombre d'erreurs corrigées par ECC correspond au nombre d'erreurs résolues avec succès par la puce ECC.
Nombre d'erreurs
Lors des tests, si la mémoire échoue pour l'un de ces tests, le nombre d'erreurs incrémentées augmente. Si je me souviens bien, il compte le nombre d'adresses qui ont échoué au test.
Nombre d'erreurs ECC
Mémoire ECC est un type particulier de puce mémoire utilisé pour empêcher la corruption des données. Votre colonne ECC Errs compte le nombre de problèmes résolus par ECC.
(ECC est lent et coûteux et s’applique essentiellement aux systèmes critiques qui ne peuvent pas être dérangés pour échanger RAM.)
Numéro de test
Memtest effectue différents types de tests sur votre mémoire, décrits sur le site Web Memtest86 . Juste comme une traduction en anglais simple et rapide:
Test 0: Test d'adresse à pied
Memtest écrira 00000001 dans le premier emplacement de mémoire, 00000010 dans le suivant, etc., en répétant ce motif tous les 8 octets. Ensuite, il lit la mémoire et s'assure que la valeur n'a pas changé. ( La source )
Tests 1 et 2: Test d'adresse propre
Memtest écrit chaque emplacement de mémoire avec sa propre adresse et vérifie que la valeur n'a pas changé.
Le test 1 est séquentiel et le test 2 est parallèle (c’est-à-dire utilise la simultanéité).
Test 3 & 4 Test d'inversions en mouvement
Essentiellement, ce test charge les 0 en mémoire, puis
- prend chaque emplacement de mémoire (à partir du premier/emplacement le plus bas),
- et écrit l'inverse du motif (je dirais que c'est un bitwise NON, mais je n'ai trouvé aucune documentation à ce sujet).
Le but ici est d'essayer de tester chaque bit et ses bits adjacents "toutes les combinaisons possibles de 0 et de 1".
Le test 3 n'utilise pas la concurrence, alors que le test 4 l'utilise.
Test 5: Inversions en mouvement, Pat 8 bits
La méthode des inversions en mouvement est à nouveau utilisée, mais cette fois-ci avec les 1 en marche du test 0 par blocs de 8 bits.
Test 6: Inversions en mouvement, modèle aléatoire
Memtest utilise des nombres aléatoires au lieu de tous les 0 ou des 1 en marchant.
Test 7: bloquer le mouvement
Celui-ci est amusant. Il charge des motifs en mémoire, les déplace par blocs de 4 Mo et les vérifie.
Test 8: Inversion en mouvement, Pat 32 bits
Identique au test 5, mais utilise plutôt des blocs de 32 bits. Celui-ci charge en fait toutes les valeurs 32 bits possibles à chaque emplacement.
Test 9: Nombres Aléatoires
Celui-ci charge des nombres pseudo-aléatoires en mémoire et les vérifie. La bonne chose à propos du générateur de nombres pseudo-aléatoires est qu’il n’est pas très aléatoire (si vous avez déjà exécuté printf("%d", Rand()); dans un programme C sans semer et obtenu le nombre oh-so-aléatoire 41, vous voyez ce que je veux dire). Donc, il vérifie en réinitialisant le séparateur de nombres aléatoires et en relançant le générateur.
Test 10: Modulo-X
Tous les 20 emplacements, il écrit un motif (tous les 0 ou tous les 1) et écrit le complément dans tous les autres emplacements, puis vérifie.
Test 11: Test de décoloration des bits
Celui-ci charge le RAM avec tous les 1 (et à nouveau avec tous les 0), attend 5 minutes et voit si l'une des valeurs change.