J'ai fait des tests de synchronisation et j'ai également lu des articles comme celui-ci (dernier commentaire), et il semble que dans Release build, les valeurs flottantes et doubles prennent le même temps de traitement.
Comment est-ce possible? Lorsque le flottant est moins précis et plus petit que les valeurs doubles, comment le CLR peut-il obtenir des doubles dans le même temps de traitement?
c#
.net
clr
performance
Joan Venge
la source
la source
Réponses:
Sur les processeurs x86, au moins,
float
etdouble
seront chacun convertis en un réel de 10 octets par le FPU pour traitement. Le FPU n'a pas d'unités de traitement distinctes pour les différents types à virgule flottante qu'il prend en charge.Le conseil séculaire qui
float
est plus rapide qu'il y adouble
100 ans, lorsque la plupart des processeurs n'avaient pas de FPU intégrés (et peu de gens avaient des puces FPU distinctes), de sorte que la plupart des manipulations en virgule flottante étaient effectuées dans un logiciel. Sur ces machines (qui étaient alimentées par la vapeur générée par les fosses de lave), il était plus rapide d'utiliserfloat
s. Maintenant, le seul avantage réel desfloat
s est qu'ils prennent moins de place (ce qui n'a d'importance que si vous en avez des millions).la source
J'avais un petit projet où j'utilisais CUDA et je me souviens que le flotteur était plus rapide que le double là aussi. Pour une fois, le trafic entre l'hôte et le périphérique est plus faible (l'hôte est le CPU et la RAM "normale" et le périphérique est le GPU et la RAM correspondante). Mais même si les données résident sur l'appareil tout le temps, elles sont plus lentes. Je pense avoir lu quelque part que cela a changé récemment ou est censé changer avec la prochaine génération, mais je ne suis pas sûr.
Il semble donc que le GPU ne puisse tout simplement pas gérer la double précision de manière native dans ces cas, ce qui expliquerait également pourquoi GLFloat est généralement utilisé plutôt que GLDouble.
(Comme je l'ai dit, ce n'est que pour autant que je me souvienne, je suis tombé sur cela en recherchant un flotteur ou un double sur un processeur.)
la source
Cependant, il existe encore des cas où les flottants sont préférés - avec le codage OpenGL par exemple, il est beaucoup plus courant d'utiliser le type de données GLFloat (généralement mappé directement en flottant 16 bits) car il est plus efficace sur la plupart des GPU que GLDouble.
la source
Cela dépend du système 32 bits ou 64 bits . Si vous compilez en 64 bits, le double sera plus rapide. Compilé en 32 bits sur 64 bits (machine et système d'exploitation), le flottement a été 30% plus rapide:
la source
Math
fonctionne avec double. Mais vous avez mal lu mon message: mes tests m'ont montré que je flottais mieux en performance.float
etdouble
sont pratiquement identiques. Moins de 0,3% de différence en moyenne sur de nombreux essais indépendants, où chaque essai s'exerçait à multiplier, diviser et ajouter des opérations sur des variables chaînées consécutivement (pour éviter que les optimisations du compilateur ne gênent). J'ai essayé une deuxième série de tests avecMath.Sin()
etMath.Sqrt()
et j'ai également obtenu des résultats identiques.