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 d'erreurs d'une unité . Les erreurs sont généralement des signes de mauvaises bandes de RAM.

É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 l' 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 sur: 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équentiel]

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 [Bloc en mouvement, 64 coups]

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, pat 32 bits]

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 à une interférence 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 de perte de contraste, 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. Une passe complète est une série de tests achevés qui ont 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 ECCest défini sur off. ECC signifie Mémoire à code de correction d'erreur. Il s'agit d'un mécanisme permettant de détecter et de 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. ECC ne devrait pas avoir à être invoqué 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 correspondant au numéro de test de la liste déjà mentionnée ci-dessus. La deuxième colonne ( Pass ) indique si ce test est réussi. Dans le cas de l'exemple, le test 7 n'a pas de réussite.

La troisième colonne ( Adresse en échec ) 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 ( bonne ) et cinquième ( mauvaise ) colonne 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 des bits exacts en échec.

La septième colonne ( Count ) indique le nombre d'erreurs consécutives avec la même adresse et les bits défaillants.

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

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

La mémoire ECC est un type particulier de puce mémoire utilisée pour empêcher la corruption des données. Votre ECC Errscolonne compte le nombre de problèmes résolus par ECC.

(ECC est lent et coûteux et s’applique essentiellement aux systèmes stratégiques qui ne peuvent pas être dérangés pour échanger la 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 écrit 00000001dans le premier emplacement de la mémoire, 00000010dans le suivant, et ainsi de suite, 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é. ( 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 (utilise la simultanéité).

Test 3 et 4 Test des inversions en mouvement

Essentiellement, ce test charge les 0 en mémoire, puis

1. prend chaque emplacement de mémoire (à partir du premier / emplacement le plus bas),
2. 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à participé printf("%d", rand());à un programme C sans générer de graine 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

Celui-ci charge la RAM avec tous les 1 (et encore avec tous les 0), attend 5 minutes et voit si l'une des valeurs change.

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 prennent en charge ce support 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.