Qu'est-ce que FLOP / s et est-ce une bonne mesure de performance?

Question

On m'a demandé de mesurer les performances d'un programme fortran qui résout des équations différentielles sur un système à plusieurs processeurs. Mon employeur insiste pour que je mesure FLOP / s (opérations flottantes par seconde) et que je compare les résultats à des points de repère ( LINPACK ) mais je ne suis pas convaincu que ce soit la voie à suivre, tout simplement parce que personne ne peut m'expliquer ce qu'est un FLOP.

J'ai fait des recherches sur ce qu'est exactement un FLOP et j'ai obtenu des réponses plutôt contradictoires. Une des réponses les plus populaires que j'ai eu était '1 FLOP = Une addition et une opération de multiplication'. Est-ce vrai? Si oui, encore une fois, physiquement, qu'est-ce que cela signifie?

Quelle que soit la méthode que j'utilise, elle doit être évolutive. Certaines des versions du code résolvent des systèmes comportant plusieurs millions d'inconnues et leur exécution prend des jours.

Quels seraient d'autres moyens efficaces de mesurer les performances dans mon cas (le résumé de mon cas étant un code fortran qui effectue de nombreux calculs arithmétiques maintes et maintes fois pendant plusieurs jours sur plusieurs centaines de CPU)?

Answer 1

C’est une mesure assez décente de la performance, du moment que vous comprenez exactement ce qu’elle mesure.

FLOPS est, comme son nom l’indique, des opérations en virgule flottante par seconde, ce qui constitue un FLOP peut varier en fonction du processeur. (Certains processeurs peuvent effectuer l'addition et la multiplication en une seule opération, d'autres pas, par exemple). Cela signifie qu'en tant que mesure de performance, elle est assez proche du matériel, ce qui signifie que 1) vous devez connaître votre matériel pour calculer les FLOPS idéaux sur une architecture donnée, ainsi que votre algorithme et son implémentation pour comprendre comment. beaucoup d’opérations en virgule flottante, il est en réalité composé de.

Quoi qu’il en soit, c’est un outil utile pour examiner votre capacité à utiliser le processeur. Si vous connaissez les performances de pointe théoriques du processeur dans FLOPS, vous pouvez évaluer votre efficacité à utiliser les unités à virgule flottante du processeur, qui sont souvent difficiles à utiliser efficacement. Un programme qui exécute 30% des FLOPS dont le CPU est capable a de la place pour une optimisation. Celui qui fonctionne à 70% ne sera probablement pas beaucoup plus efficace si vous ne modifiez pas l'algorithme de base. Pour des algorithmes lourds en mathématiques comme le vôtre, il s’agit plus ou moins du moyen standard de mesurer les performances. Vous pouvez simplement mesurer le temps nécessaire à l'exécution d'un programme, mais cela varie énormément en fonction du processeur. Mais si votre programme utilise 50% de l’UC (par rapport au nombre maximal de FLOPS), la valeur est un peu plus constante (elle variera néanmoins entre des architectures de CPU radicalement différentes, mais elle est beaucoup plus cohérente que le temps d’exécution).

Mais sachant que "mon processeur est capable de gérer X GFLOPS, et que je n'atteins en réalité qu'un débit de 20%, par exemple". est très une information précieuse dans un logiciel performant. Cela signifie que quelque chose autre que les opérations à virgule flottante vous retient et empêche les unités de PF de fonctionner efficacement. Et comme les unités de PF constituent l'essentiel du travail, cela signifie que votre logiciel a un problème.

Il est facile de mesurer "Mon programme fonctionne en X minutes", et si vous pensez que c'est inacceptable, vous pouvez y aller, "Je me demande si je peux couper 30% de ce", mais vous ne le faites pas < em> savez si cela est possible, à moins que vous ne déterminiez exactement le volume de travail à effectuer et les capacités maximales du processeur. Combien de temps voulez-vous consacrer à l'optimisation, si vous ne savez même pas si le processeur est fondamentalement capable d'exécuter plus d'instructions par seconde?

Il est très facile d’empêcher l’utilisation efficace de l’unité FP de la CPU, en ayant trop de dépendances entre les opérations FP, ou en ayant trop de branches ou autres empêchant une planification efficace. Et si c’est ce qui retient votre implémentation, vous avez besoin de le savoir. Vous devez savoir que "je n'obtiens pas le débit de la PF qui devrait être possible, alors clairement d'autres parties de mon code empêchent que les instructions de la FP soient disponibles lorsque le processeur est prêt à en émettre une."

Pourquoi avez-vous besoin d'autres moyens de mesurer les performances? Qu'est-ce qui ne va pas avec le calcul du nombre de FLOPS que votre patron vous a demandé? ;)

Answer 2

Je voudrais juste ajouter quelques points plus précis:

La

• division est spéciale. Comme la plupart des processeurs peuvent faire une addition, une comparaison ou une multiplication en un seul cycle, ceux-ci sont tous comptés comme un flop. Mais la division prend toujours plus de temps. Cela dépend plus longtemps du processeur, mais il existe une sorte de norme de facto dans la communauté HPC qui compte une division comme quatre flops.

• Si un processeur dispose d'une instruction multipliée-addition fusionnée qui effectue une multiplication et une addition en une seule instruction - généralement A + = B * C - qui compte pour 2 opérations .

• Veillez toujours à bien distinguer les flops à simple précision des flops à double précision . Un processeur capable de gérer autant de gigaflops à simple précision ne peut prendre en charge qu'une infime fraction de ce nombre de gigaflops à double précision. Les processeurs AMD Athlon et Phenom peuvent généralement faire deux fois moins de flops à double précision que des processeurs à simple précision. Les processeurs ATI Firestream peuvent généralement faire 1/5 de fois le nombre de flops en double précision en simple précision. Si quelqu'un essaie de vous vendre un processeur ou un progiciel et qu'il cite simplement des flops sans préciser lequel, vous devriez les appeler.

• Les termes mégaflop, gigaflop, téraflop, etc. sont d'usage courant. Il s’agit de facteurs 1 000 , et non 1024 . Par exemple, 1 mégaflop = 1 000 000 flop / sec et non 1 048 576. Tout comme pour les tailles de disque, il y a une certaine confusion à ce sujet.

Answer 3

"comparez les résultats avec des points de repère" et faire quoi?

FLOPS signifie que vous avez besoin

1) FLOP par unité de travail.

2) l'heure de cette unité de travail.

Supposons que vous ayez un fichier d’entrée qui effectue 1 000 itérations par boucle. La boucle est une unité de travail pratique. Il est exécuté 1 000 fois. Cela prend une heure.

La boucle comporte des additions et des multiplications, quelques divisions et une racine carrée. Vous pouvez compter des additions, des multiplications et des divisions. Vous pouvez compter cela dans la source, en recherchant +, * et /. Vous pouvez trouver la sortie en langage assembleur à partir du compilateur et la compter là aussi. Vous pouvez obtenir des numéros différents. Lequel a raison? Demandez à votre patron.

Vous pouvez compter les racines carrées, mais vous ne savez pas vraiment ce qu’il fait en termes de multiplication et d’ajout. Vous devrez donc faire quelque chose comme multiplier le point de repère par rapport à la racine carrée pour avoir une idée du temps que prend une racine carrée.

Maintenant, vous connaissez les FLOPS dans votre boucle. Et vous connaissez le temps de le lancer 1 000 fois. Vous connaissez FLOPS par seconde.

Ensuite, vous regardez LINPACK et constatez que vous êtes plus lent. Maintenant quoi? Votre programme n'est pas LINPACK et il est plus lent que LINPACK. Les chances sont vraiment bonnes que votre code sera plus lent. Si votre code n'a pas été écrit et optimisé sur le même nombre d'années qu'un LINPACK, vous serez plus lent.

Voici l'autre partie. Votre processeur possède une classe FLOPS définie par rapport à différents points de repère. Votre algorithme n'est pas l'un de ces points de repère, vous ne pouvez donc pas vous y prendre. Est-ce mauvais? Ou est-ce la conséquence évidente de ne pas être une référence?

Quel sera le résultat concret?

Mesurer avec une base de code de référence ne fera que vous dire que votre algorithme n'est pas l'algorithme de référence. Il est clair que vous serez différent. généralement plus lent.

Évidemment, le résultat de la mesure par rapport à LINPACK sera (a) que vous êtes différent et donc (b) que vous devez optimiser.

La mesure n’a vraiment de valeur que si elle est faite contre vous-même . Pas un mélange d'instructions hypothétique, mais votre propre mélange d'instructions. Mesurer votre propre performance. Faire un changement. Voyez si vos performances, comparées à vous-même, s’améliorent ou empirent.

FLOPS n'a pas d'importance. Ce qui compte, c'est le temps par unité de travail. Vous ne rencontrerez jamais les paramètres de conception de votre matériel, car vous n'exécutez pas le test de performance attendu par vos concepteurs.

LINPACK n'a pas d'importance. Ce qui compte, c’est votre base de code et les modifications que vous apportez pour améliorer les performances.

Answer 4

Ancienne question avec des réponses anciennes, si populaires, qui ne sont pas tout à fait géniales, OMI.

A & # 8220; FLOP & # 8221; est une opération mathématique en virgule flottante. FLOPS & # 8221; peut signifier deux choses:

• Le pluriel simple de & # 8220; FLOP & # 8221; (c’est-à-dire que l’opération X prend 50 FLOP & # 8221;)
• Le taux des FLOP dans le premier sens (opérations mathématiques à virgule flottante par seconde)

Lorsqu'il n'est pas clair dans le contexte, il est souvent difficile de comprendre l'ambiguïté en écrivant l'ancien sous la forme "FLOPs & # 8221". et ce dernier sous le nom "FLOP / s".

Les

FLOP sont ainsi appelés pour les distinguer des autres types d'opérations de la CPU , telles que les opérations mathématiques sur nombres entiers, les opérations logiques, les opérations au niveau des bits, les opérations en mémoire et les opérations de branchement, qui ont des coûts différents (lire <8220; prennent différentes durées & # 8221;) qui leur sont associées.

La pratique du & # 8220; comptage FLOP & # 8221; remonte aux tout débuts de l'informatique scientifique, lorsque les FLOP étaient relativement onéreux, prenant de nombreux cycles de processeur. Un coprocesseur mathématique 80387, par exemple, a nécessité environ 300 cycles pour une multiplication unique. C'était à un moment avant le traitement en pipeline et avant que le fossé entre les vitesses d'horloge du processeur et de la mémoire ne se soit vraiment ouvert: les opérations de mémoire ne prenaient qu'un cycle ou deux, et le branchement (la prise de décision) était tout aussi bon marché. À l'époque, si vous pouviez éliminer un seul FLOP au profit d'une douzaine d'accès mémoire, vous feriez un gain. Si vous pouviez éliminer un seul FLOP au profit d'une douzaine de branches, vous feriez un gain. Ainsi, dans le passé, il était logique de compter les FLOP sans trop s’inquiéter des références et des branches de la mémoire, car les FLOP dominaient fortement le temps d’exécution car ils étaient individuellement très coûteux par rapport à d’autres types d’opérations.

Plus récemment, la situation s'est inversée. Les FLOP sont devenus très bon marché & # 8212; Tous les noyaux Intel modernes peuvent effectuer environ deux FLOP par cycle (bien que la division reste relativement onéreuse) & # 8212; et les accès à la mémoire et les branches sont comparativement beaucoup plus coûteux: un hit de cache N1 coûte environ 3 ou 4 cycles, une extraction de la mémoire principale coûte 150 €. compte tenu de cette inversion, il n’est plus vrai que supprimer un FLOP au profit d’un accès mémoire se traduira par un gain ; en fait, c'est peu probable. De même, il est souvent moins coûteux de & # 8220; simplement faire & # 8221; un FLOP, même s'il est redondant, plutôt que de décider de le faire ou non. C’est à peu près le contraire de la situation d’il ya 25 ans.

Malheureusement, la pratique du comptage à l'aveuglette en tant que mesure absolue du mérite algorithmique a persisté bien au-delà de sa date de péremption. L'informatique scientifique moderne est beaucoup plus axée sur la gestion de la bande passante mémoire & # 8212; essayer de garder les unités d’exécution que font les FLOP alimentées en permanence en données & # 8212; que de réduire le nombre de FLOP. La référence à LINPACK (qui était essentiellement obsolète par LAPACK il y a 20 ans) m'amène à penser que votre employeur est probablement d'une très vieille école qui n'a pas intériorisé le fait que l’établissement d’attentes en matière de performance n’est plus seulement une question de comptage FLOP. Un solveur qui effectue deux fois plus de FLOP peut être vingt fois plus rapide qu'un autre s'il dispose d'un modèle d'accès à la mémoire et d'une structure de données beaucoup plus favorables.

Le résultat de tout cela est que l'évaluation des performances des logiciels à forte intensité de calcul est devenue beaucoup plus complexe qu'auparavant . Le fait que les FLOP soient devenues moins chères est énormément compliqué par la grande variabilité dans les coûts des opérations et des branches de mémoire. Lorsqu’il s’agit d’évaluer des algorithmes , le simple comptage FLOP n’informe tout simplement pas les performances globales

Answer 5

Un FLOPS est, comme vous l'avez dit, une opération à virgule flottante par seconde. Par exemple, si vous prenez exactement une seconde pour une opération (comme ajouter, soustraire, multiplier ou diviser deux valeurs et renvoyer le résultat), votre performance est simplement de 1 FLOPS. Un processeur récent réalisera facilement plusieurs GigaFLOPS, c'est-à-dire plusieurs milliards d'opérations en virgule flottante par seconde.

Answer 6

Je voudrais juste essayer de le faire aller le plus vite possible, et cela nécessite de savoir où il passe son temps, en particulier s'il y a des appels de fonction qui pourraient être évités.

Je le fais par la méthode simple qui consiste à l’interrompre plusieurs fois pendant son exécution et à voir ce qu’il fait. Voici le genre de choses que je trouve:

• La plupart du temps, il est en train de calculer le dérivé et / ou le jacobien. Une grande partie de ce temps peut aller aux appels de fonction mathématique tels que exp () , log () et sqrt () . Celles-ci sont souvent répétées avec des arguments identiques et peuvent être mémorisées. (Accélération massive.)

• La plupart du temps est consacrée au calcul des dérivées trop souvent car les tolérances d'intégration sont plus strictes que nécessaire. (Plus rapide)

• Si un algorithme d'intégration implicite (tel que DLSODE Gear) est utilisé parce que les équations sont supposées rigides, il est probable qu'ils ne le soient pas et que quelque chose comme Runge-Kutta pourrait être utilisé. (DVERK). (Encore plus rapide)

• Peut-être qu'un algorithme matrice-exposant pourrait être utilisé si le modèle est linéaire (DGPADM). C'est une grande victoire pour la performance et la précision, et est insensible à la rigidité. (Bien plus vite)

• Plus haut dans la pile d'appels, il se peut que les mêmes intégrations soient répétées avec des paramètres légèrement différents, afin de déterminer un gradient de différence direct ou central de la solution par rapport à ces paramètres. Si les équations différentielles sont elles-mêmes différentiables, il peut être possible d’obtenir ces gradients de manière analytique ou en les complétant avec des équations de sensibilité. Ce n'est pas seulement beaucoup plus rapide, mais beaucoup plus précis, ce qui peut accélérer les choses encore plus haut dans la pile.

Vous pouvez voir chaque niveau de la pile comme une opportunité de trouver des éléments à optimiser, et les accélérations se compliqueront. Ensuite, lorsque vous utilisez multi-cpu, en supposant qu’il soit parallélisable, cela devrait fournir son propre facteur multiplicatif.

Revenons donc aux FLOP. Vous pouvez essayer de maximiser FLOPs / seconde , mais cela peut également être beaucoup plus utile pour minimze FLOPs / run , en optimisant à tous les niveaux de la pile. Dans tous les cas, les mesurer ne vous dit presque rien.

Answer 7

Votre employeur a raison.
Le seul moyen de mesurer l'efficacité de votre programme Fortran (ou de tout autre programme, d'ailleurs) est de le tester par rapport à des critères de référence standard, s'ils existent.

Et, à propos des FLOP, il signifie "opérations en virgule flottante par seconde". - consultez la définition sur Wikipedia.

Answer 8

Je ne pense pas que mesurer les FLOPS sera très utile.

Le nombre de FLOPS atteints vous indiquera la charge occupée par votre algorithme, mais pas la performance de votre algorithme lui-même.

Vous pouvez trouver deux algorithmes différents qui entraînent le même nombre de FLOPS par le processeur, mais un vous fournit le résultat souhaité deux fois plus vite.

Je pense que vous feriez mieux de regarder une statistique beaucoup plus «supérieure», telle que le nombre d'équations différentielles résolues par unité de temps (c'est, après tout, l'objectif de votre algorithme).

D'autre part, mesurer le nombre de FLOPS atteints peut vous aider à améliorer votre algorithme, car il vous indiquera à quel point vous gardez le processeur.