Ce logiciel teste la mémoire GPU pour les erreurs matérielles et les erreurs souples à l'aide de CUDA (ou OpenCL).
Il s'agit d'une fourche du projet original et non tenu de longue date à https://sourceforge.net/projects/cudagpumemtest/.
Après notre fourche en 2013 (V1.2.3), nous nous sommes principalement concentrés sur la prise en charge des nouvelles versions CUDA et la prise en charge du nouveau matériel NVIDIA. Les refontes de traction qui entretiennent les versions OpenCL sont néanmoins les bienvenues.
Licence open source de l'Illinois
Université de l'Illinois / NCSA
Licence open source
Copyright 2009-2012, Université de l'Illinois. Tous droits réservés.
Copyright 2013-2019, les développeurs de Pimengpu à Helmholtz-Zentrum Dresde-Rossendorf
Développé par:
Laboratoire de systèmes innovants
Centre national pour les applications de supercalculation
http://www.ncsa.uiucc.edu/aboutus/directorates/isl.html
Fourni et maintenu pour les nouveaux GPU NVIDIA depuis 2013 par:
Axel Huebl et René Widera
Groupe de physique des rayonnements informatiques
Helmholtz-Zentrum Dresde-Rossendorf
https://www.hzdr.de/crp
L'autorisation est accordée gratuitement par la présente à toute personne qui obtient une copie de ce logiciel et des fichiers de documentation associés (le "logiciel"), pour traiter le logiciel sans restriction, y compris sans limiter les droits d'utilisation, de copier, de modifier, de fusionner , publier, distribuer, sous-licencier et / ou vendre des copies du logiciel, et pour permettre aux personnes à qui le logiciel est fourni pour le faire, sous réserve des conditions suivantes:
Les redistributions du code source doivent conserver l'avis de droit d'auteur ci-dessus, cette liste de conditions et les clauses de non-responsabilité suivantes.
Les redistributions sous forme binaire doivent reproduire l'avis de droit d'auteur ci-dessus, cette liste des conditions et les clauses de non-responsabilité suivantes dans la documentation et / ou d'autres documents fournis avec la distribution.
Ni les noms du laboratoire des systèmes innovants, le National Center for Supercomputing Applications, ni les noms de ses contributeurs ne peuvent être utilisés pour approuver ou promouvoir des produits dérivés de ce logiciel sans autorisation écrite préalable spécifique.
Le logiciel est fourni "tel quel", sans garantie d'aucune sorte, express ou implicite, y compris, mais sans s'y limiter, les garanties de qualité marchande, d'adéquation à un usage particulier et de non-contrefaçon. En aucun cas, les contributeurs ou les titulaires de droits d'auteur ne seront pas responsables de toute réclamation, dommage ou autre responsabilité, que ce soit dans une action de contrat, de délit ou autre, découlant de, hors du logiciel ou de l'utilisation ou d'autres transactions avec les relations avec la LOGICIEL.
À l'intérieur du répertoire source, exécutez:
mkdir build
cd build
# build for NVIDIA architecture sm_35
cmake -DCMAKE_CUDA_ARCHITECTURES=35 ..
makeÀ l'intérieur du répertoire source, exécutez:
mkdir build
cd build
# build for NVIDIA architecture MI2XX
cmake -DCUDA_MEMTEST_BACKEND=hip -DGPU_TARGETS=gfx90a ..
makeNote:
.. est le chemin du répertoire source. Nous fournissons également le package cuda-memtest dans le Spack Package Manager.
cuda_memtest
Le comportement par défaut consiste à exécuter le test sur tous les GPU disponibles à l'infini. Il existe des options pour modifier le comportement par défaut.
cuda_memtest --disable_all --enable_test 10
cuda_memtest --stress
Cela exécute le test 10 (le test de contrainte). --stress est équivalent à --disable_all --enable_test 10 --exit_on_error
cuda_memtest --stress --num_iterations 100 --num_passes 1
Celui-ci fait une vérification de santé mentale rapide pour les GPU avec un court terme de test 10. Plus à ce sujet plus tard.
Voir le message d'aide par
cuda_memtest --help
Il y a un simple script sanity_check.sh dans le répertoire. Ce script vérifie rapidement si un GPU ou tous les GPU sont en mauvaise santé.
Exemple d'utilisation:
# copy the cuda_memtest binary first into the same location as this script, e.g.
cd ..
mv build/cuda_memtest . ./sanity_check.sh 0 //check GPU 0
./sanity_check.sh 1 //check GPU 1
./sanity_check.sh //check All GPUs in the system
Remarque de la fourche: nous exécutons directement le binaire cuda_memtest . Considérez ce script comme une source d'inspiration, du moins.
Même si vous compilez avec AMD Hip, le binaire de l'outil sera nommé cuda_memtest .
Si vous exécutez sur AMD GPU via la hanche, l'outil mentionnera partout CUDA au lieu de la hanche.
Nous ne maintenons pas la version OpenCL de cette base de code. Les demandes de tir de redressement et de mise à jour des capacités d'OpenCL sont les bienvenues.
En cours d'exécution
cuda_memtest --list_tests
Imprimera tous les tests et leurs courtes descriptions, au 18/06/2009, nous avons mis en œuvre 11 tests
Test0 [Walking 1 bit]
Test1 [Own address test]
Test2 [Moving inversions, ones&zeros]
Test3 [Moving inversions, 8 bit pat]
Test4 [Moving inversions, random pattern]
Test5 [Block move, 64 moves]
Test6 [Moving inversions, 32 bit pat]
Test7 [Random number sequence]
Test8 [Modulo 20, random pattern]
Test9 [Bit fade test] ==disabled by default==
Test10 [Memory stress test]
Tout d'abord, un noyau est lancé pour écrire un modèle. Ensuite, nous quittons le noyau pour que la mémoire puisse être rincée. Ensuite, nous commençons un nouveau noyau pour lire et vérifier si la valeur correspond au modèle. Une erreur est enregistrée si elle ne correspond pas à chaque emplacement de mémoire. Dans le même noyau, le complément du modèle est écrit après la vérification. Le troisième noyau est lancé pour relire la valeur et vérifie le complément du modèle.
Tester 0 [Walking 1 bit]
Ce test change un bit une fois dans l'adresse mémoire pour voir qu'il passe à un emplacement de mémoire différent. Il est conçu pour tester les fils d'adresse.
Test 1 [Own address test]
Chaque emplacement de mémoire est rempli de sa propre adresse. Le noyau suivant vérifie si la valeur dans chaque emplacement de mémoire est toujours d'accord avec l'adresse.
Test 2 [Moving inversions, ones&zeros]
Ce test utilise l'algorithme d'inversions en mouvement avec des modèles de tous ceux et zéros.
Test 3 [Moving inversions, 8 bit pat]
C'est la même chose que le test 1 mais utilise un motif de 8 bits de «marche» et de zéros. Ce test détectera mieux les erreurs subtiles dans les puces de mémoire "larges".
Test 4 [Moving inversions, random pattern]
Le test 4 utilise le même algorithme que le test 1 mais le modèle de données est un nombre aléatoire et son complément. Ce test est particulièrement efficace pour trouver du mal à détecter les erreurs sensibles aux données. La séquence de nombres aléatoires est différente à chaque passe, donc les passes multiples augmentent l'efficacité.
Test 5 [Block move, 64 moves]
Ce test souligne la mémoire en mouvement des souvenirs de blocs. La mémoire est initialisée avec des modèles de décalage qui sont inversés tous les 8 octets. Ensuite, des blocs de mémoire sont déplacés. Une fois les mouvements terminés, les modèles de données sont vérifiés. Étant donné que les données sont vérifiées uniquement une fois les mouvements de mémoire terminés, il n'est pas possible de savoir où l'erreur s'est produite. Les adresses rapportées sont uniquement pour l'endroit où le mauvais schéma a été trouvé.
Test 6 [Moving inversions, 32 bit pat]
Il s'agit d'une variation de l'algorithme d'inversions en mouvement qui déplace le modèle de données laissé 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 nécessaires. Ce test est assez efficace pour détecter les erreurs sensibles aux données, mais le temps d'exécution est long.
Test 7 [Random number sequence]
Ce test écrit une série de nombres aléatoires en mémoire. Un bloc (1 Mo) de mémoire est initialisé avec des motifs aléatoires. Ces modèles et leurs compléments sont utilisés dans le test d'inversions en mouvement avec le reste de la mémoire.
Test 8 [Modulo 20, random pattern]
Un modèle aléatoire est généré. Ce modèle est utilisé pour définir chaque 20e emplacement de mémoire en mémoire. Le reste de l'emplacement de la mémoire est défini sur le complément du motif. Répétez ceci pour 20 fois et chaque fois que l'emplacement de la mémoire pour définir le motif est décalé à droite.
Test 9 [Bit fade test, 90 min, 2 patterns]
Le test de fondu bit initialise toute la mémoire avec un motif puis dort pendant 90 minutes. Ensuite, la mémoire est examinée pour voir si des bits de mémoire ont changé. Tous et tous les modèles zéro sont utilisés. Ce test prend 3 heures. Le test de fondu bit est désactivé par défaut
Test 10 [memory stress test]
Stressons la mémoire autant que possible. Un motif aléatoire est généré et un noyau de grande taille de grille et de la taille du bloc est lancé pour définir toute la mémoire sur le motif. Un nouveau noyau de lecture et d'écriture est lancé immédiatement après le noyau d'écriture précédent pour vérifier s'il y a des erreurs en mémoire et définir la mémoire sur le complément. Ce processus est répété pour 1000 fois pour un modèle. Le noyau est écrit comme pour atteindre la bande passante maximale entre la mémoire globale et le GPU. Cela augmentera les chances d'attraper une erreur logicielle. En pratique, nous avons également trouvé ce test très utile pour rincer des erreurs matérielles.
