Comment calculer Gflops d'un noyau

Je veux une mesure de la façon dont beaucoup de la performance de pointe de mon kernel archives.

Dire que j'ai une NVIDIA Tesla C1060, qui a un pic GFLOPS de 622.08 (~= 240Cores * 1300MHz * 2).
Maintenant, dans mon noyau, j'ai compté pour chaque thread 16000 flop (4000 x (2 soustraction, de multiplication de 1 et 1 sqrt)). Alors, quand j'ai 1 000 000 de threads, je viendrait avec 16GFLOP. Et comme le noyau prend 0,1 secondes, je voudrais archive 160GFLOPS, qui représente un quart de la performance de pointe. Maintenant mes questions:

Cette approche est-elle correcte?
Que sur des comparaisons (if(a>b) then....)? Dois-je les considérer ainsi?
Puis-je utiliser CUDA profiler plus facile et plus précise des résultats? J'ai essayé le instructions compteur, mais je ne pouvais pas comprendre, ce que la figure moyens.

sœur question: Comment calculer l'atteinte de la bande passante d'un noyau CUDA

OriginalL'auteur Framester | 2011-10-24

cuda profiling

21

D'abord quelques remarques générales:

En général, ce que vous faites est surtout un exercice de futilité et de l'est à l'inverse de la façon dont la plupart des gens seraient probablement aller sur l'analyse des performances.

La première observation à faire est que la valeur de crête que vous citez est strictement pour virgule flottante multiply-add instructions (FMAD), qui comptent comme deux FLOPS, et peut-être à la retraite au taux maximum de l'un par cycle. D'autres opérations en virgule flottante qui prennent leur retraite à un taux maximum de l'un par cycle officiellement seulement être classée comme un seul FLOP, tandis que d'autres peuvent nécessiter plusieurs cycles à la retraite. Donc, si vous avez décidé de citer la performance du noyau à l'encontre de ce pic, vous êtes vraiment comparer vos codes de rendement par rapport à un flux de pure FMAD instructions, et rien de plus.

Le deuxième point est que, lorsque les chercheurs devis FLOP/s valeurs à partir d'un morceau de code, ils sont généralement à l'aide d'un modèle FLOP compter de l'opération, ne pas essayer de compter les instructions. La matrice de la multiplication et de la Linpack la factorisation LU de référence sont des exemples classiques de cette approche à l'analyse comparative de la performance. La limite inférieure de l'opération nombre de ces calculs est exactement connue, le calcul du débit est tout simplement que la limite inférieure divisée par le temps. L'instruction elle-même le comte est sans importance. Les programmeurs utilisent souvent toutes sortes de techniques, y compris rundundant calculs, de spéculation ou prédictive des calculs, et une foule d'autres idées pour rendre le code plus rapide. Le véritable FLOP compter de ce type de code est sans importance, la référence est toujours le modèle FLOP comte.

Enfin, lorsque l'on cherche à quantifier les performances, il ya habituellement seulement deux points de la comparaison de réel intérêt
- N'version du code de courir plus vite que la version B sur le même matériel?
- Matérielle d'Un meilleur rendement que le matériel B à faire la tâche d'intérêt?
Dans le premier cas, vous avez vraiment besoin de mesurer le temps d'exécution. Dans le second, une mesure appropriée n'est généralement pas de FLOP/s, il est utile d'opérations par unité de temps (enregistrements par seconde dans le tri de cellules par seconde dans un de mécanique des fluides de simulation, etc). Parfois, comme mentionné ci-dessus, la durée de ces opérations peut être le modèle FLOP compter d'une opération de connu théorique de la complexité. Mais la véritable instruction à virgule flottante compter rarement, si jamais, il entre dans l'analyse.

Si votre intérêt est vraiment au sujet de l'optimisation et de la compréhension de la performance de votre code, alors peut-être cette présentation par Paulius Micikevicius de NVIDIA pourrait être d'intérêt.

Aborder le point questions:

Cette approche est-elle correcte?

À proprement parler. Si vous comptez les opérations à virgule flottante, vous devez savoir exactement FLOP compter de ce code, le GPU est en cours d'exécution. Le sqrt opération peut consommer beaucoup plus que d'un seul FLOP, en fonction de sa mise en œuvre et les caractéristiques de le nombre, c'est de l'exploitation, par exemple. Le compilateur peut aussi effectuer un grand nombre d'optimisations qui pourraient changer le mode de fonctionnement/mode de comptage. La seule façon d'obtenir un véritable décompte précis serait de démonter le code compilé et le compte de la personne à virgule flottante opérandes, peut-être même exiger des hypothèses sur les caractéristiques des valeurs le code de calcul.

Que sur des comparaisons (if(a>b) ensuite....)? Dois-je les considérer ainsi?

Ils ne sont pas à virgule flottante multiplier les opérations d'ajout, de sorte qu'aucun.

Puis-je utiliser CUDA profiler plus facile et plus précise des résultats? J'ai essayé les instructions compteur, mais je ne pouvais pas comprendre, ce que la figure moyens.

Pas vraiment. Le profileur peut pas différencier entre une virgule flottante intrusion et de tout autre type d'enseignement, (2011) FLOP compter à partir d'un morceau de code via le profiler n'est pas possible. [EDIT: voir Greg est execellent réponse ci-dessous pour une discussion sur le FLOP comptage des installations disponibles dans les versions des outils de profilage publiées depuis cette réponse a été écrite]

Merci encore talonmies pour cette prise de conscience. Il est vrai que je ne suis pas vraiment intéressé par le FLOP de comptage. Je recherche une mesure de la quantité de mon noyau est d'utiliser le potentiel de performance du GPU. Comment voulez-vous faire cela? De toute façon +1
Le pdf que j'ai lié à a quelques techniques très utiles pour l'instrumentation de code à apprendre au sujet de sa performance et de goulots d'étranglement.

OriginalL'auteur talonmies
10

Nsight VSE (>3.2) et le Visual Profiler (>=5.5) support Réalisé FLOPs de calcul. Afin de collecter les métriques les profileurs exécuter le noyau à deux fois (à l'aide du noyau de relecture). Dans le premier replay le nombre de virgule flottante instructions exécutées sont collectées (avec la compréhension de la prédication et active le masque). dans la deuxième relecture de la durée de la collecte.

nvprof et Visual Profiler ont une codé en dur définition. FMA comtes comme 2 opérations. Toutes les autres opérations sont 1 de l'opération. Le flops_sp_* compteurs sont thread d'exécution des instructions compte alors que flops_sp est la somme pondérée de sorte que certains de pondération peuvent être appliquées en utilisant les statistiques individuelles. Cependant, flops_sp_special couvre un certain nombre d'instructions différentes.

La Nsight VSE expérience de configuration permet à l'utilisateur de définir les opérations par type d'instruction.

Nsight Édition De Visual Studio

La configuration de recueillir Atteint FLOPS
1. Exécuter la commande de menu Nsight > Démarrer l'Analyse des Performances... pour ouvrir l'Éditeur d'Activité
2. Ensemble Type d'Activité à Profil CUDA Application
3. Dans les Paramètres du test set Expériences pour Exécuter à Personnalisé
4. Dans l'Expérience de la Liste ajouter Atteint FLOPS
5. Dans le volet du milieu sélectionnez Atteint FLOPS
6. Dans le volet de droite, vous pouvez personnaliser les FLOPS par l'instruction exécutée. La valeur par défaut de pondération est pour FMA et de la fonction RSQ à compter comme 2. Dans certains cas, j'ai vu RSQ 5.
7. Exécuter l'Analyse de la Session.
Visualisation Atteint FLOPS
1. Dans le nvreport ouvrir le CUDA Lance page de rapport.
2. Dans le CUDA Lance page sélectionner un noyau.
3. Dans le rapport de corrélation de volet (en bas à gauche) sélectionnez Atteint FLOPS
nvprof

Mesures Disponibles (sur un K20)
```
nvprof --query-metrics | grep flop
flops_sp:            Number of single-precision floating-point operations executed by non-predicated threads (add, multiply, multiply-accumulate and special)
flops_sp_add:        Number of single-precision floating-point add operations executed by non-predicated threads
flops_sp_mul:        Number of single-precision floating-point multiply operations executed by non-predicated threads
flops_sp_fma:        Number of single-precision floating-point multiply-accumulate operations executed by non-predicated threads
flops_dp:            Number of double-precision floating-point operations executed non-predicated threads (add, multiply, multiply-accumulate and special)
flops_dp_add:        Number of double-precision floating-point add operations executed by non-predicated threads
flops_dp_mul:        Number of double-precision floating-point multiply operations executed by non-predicated threads
flops_dp_fma:        Number of double-precision floating-point multiply-accumulate operations executed by non-predicated threads
flops_sp_special:    Number of single-precision floating-point special operations executed by non-predicated threads
flop_sp_efficiency:  Ratio of achieved to peak single-precision floating-point operations
flop_dp_efficiency:  Ratio of achieved to peak double-precision floating-point operations
```
De collecte et de Résultats
```
nvprof --devices 0 --metrics flops_sp --metrics flops_sp_add --metrics flops_sp_mul --metrics flops_sp_fma matrixMul.exe
[Matrix Multiply Using CUDA] - Starting...
==2452== NVPROF is profiling process 2452, command: matrixMul.exe
GPU Device 0: "Tesla K20c" with compute capability 3.5

MatrixA(320,320), MatrixB(640,320)
Computing result using CUDA Kernel...
done
Performance= 6.18 GFlop/s, Time= 21.196 msec, Size= 131072000 Ops, WorkgroupSize= 1024 threads/block
Checking computed result for correctness: OK

Note: For peak performance, please refer to the matrixMulCUBLAS example.
==2452== Profiling application: matrixMul.exe
==2452== Profiling result:
==2452== Metric result:
Invocations                               Metric Name                        Metric Description         Min         Max         Avg
Device "Tesla K20c (0)"
        Kernel: void matrixMulCUDA<int=32>(float*, float*, float*, int, int)
        301                                  flops_sp                             FLOPS(Single)   131072000   131072000   131072000
        301                              flops_sp_add                         FLOPS(Single Add)           0           0           0
        301                              flops_sp_mul                         FLOPS(Single Mul)           0           0           0
        301                              flops_sp_fma                         FLOPS(Single FMA)    65536000    65536000    65536000
```
REMARQUE: flops_sp = flops_sp_add + flops_sp_mul + flops_sp_special + (2 * flops_sp_fma) (environ)

Visual Profiler

Le Visual Profiler prend en charge les paramètres indiqués dans la nvprof section ci-dessus.

Pour ma compréhension. Vous dites: nvprof et Visual Profiler ont une codé en dur définition. FMA compte comme 2 opérations; Toutes les autres opérations sont 1 opération. Donc, si vous avez une combinaison de transcendetal fonctions, comme exp(), sin(), etc. et des fonctions spéciales, comme bessel fonctions (dans la version fournie par CUDA), comment les profileurs estimer le nombre d'opérations de comptage, ce qui semble être l'une des questions majeures soulevées par @talonmies?
Pour la bibliothèque de mathématiques fonctions spéciales, il devrait être OK parce que le profiler est le comptage réel des instructions sur la configuration matérielle et ceux de compiler dans les cours d'eau des instructions en virgule flottante.
Comme talonmies mentionné les "profileurs" comte not_predicated_off_thread_inst_executed pour chaque type d'instruction. Dans le Nsight VSE de configuration ci-dessus le sont les pondérations sont pour ces opcodes. Si vous développez l'Expérience de la Définition dans le volet de configuration, vous trouverez un Démontage Regex Match expérience. FLOPS est seulement une mesure utile dans un environnement contrôlé. Il n'est pas bien définie définition pour un flop. C'est pourquoi Nsight VSE prend en charge personnalisée de pondération. Je ne recommandons pas d'utiliser les données pour comparer entre les architectures.

OriginalL'auteur Greg Smith

Vous devez vous connecter pour publier un commentaire.

Nsight Édition De Visual Studio

nvprof

Visual Profiler