Je fais un travail critique de performance en C ++, et nous utilisons actuellement des calculs entiers pour les problèmes qui sont intrinsèquement en virgule flottante parce que "c'est plus rapide". Cela cause beaucoup de problèmes ennuyeux et ajoute beaucoup de code ennuyeux.
Maintenant, je me souviens avoir lu comment les calculs en virgule flottante étaient si lents environ vers les 386 jours, où je crois (IIRC) qu'il y avait un co-processeur optionnel. Mais de nos jours, avec des processeurs exponentiellement plus complexes et puissants, cela ne fait aucune différence en termes de «vitesse» si vous faites un calcul en virgule flottante ou en nombre entier? Surtout que le temps de calcul réel est minime par rapport à quelque chose comme provoquer un blocage de pipeline ou récupérer quelque chose de la mémoire principale?
Je sais que la bonne réponse est de comparer le matériel cible, quel serait un bon moyen de tester cela? J'ai écrit deux petits programmes C ++ et comparé leur temps d'exécution avec "time" sur Linux, mais le temps d'exécution réel est trop variable (cela n'aide pas que je tourne sur un serveur virtuel). À moins de passer toute ma journée à exécuter des centaines de points de repère, à créer des graphiques, etc., puis-je faire quelque chose pour obtenir un test raisonnable de la vitesse relative? Des idées ou des pensées? Ai-je complètement tort?
Les programmes que j'ai utilisés comme suit, ils ne sont en aucun cas identiques:
#include <iostream>
#include <cmath>
#include <cstdlib>
#include <time.h>
int main( int argc, char** argv )
{
int accum = 0;
srand( time( NULL ) );
for( unsigned int i = 0; i < 100000000; ++i )
{
accum += rand( ) % 365;
}
std::cout << accum << std::endl;
return 0;
}
Programme 2:
#include <iostream>
#include <cmath>
#include <cstdlib>
#include <time.h>
int main( int argc, char** argv )
{
float accum = 0;
srand( time( NULL ) );
for( unsigned int i = 0; i < 100000000; ++i )
{
accum += (float)( rand( ) % 365 );
}
std::cout << accum << std::endl;
return 0;
}
Merci d'avance!
Edit: La plate-forme qui me tient à cœur est x86 ou x86-64 standard fonctionnant sur des ordinateurs de bureau Linux et Windows.
Edit 2 (collé à partir d'un commentaire ci-dessous): Nous avons actuellement une base de code étendue. Vraiment, je me suis heurté à la généralisation selon laquelle «nous ne devons pas utiliser de flottant car le calcul des nombres entiers est plus rapide» - et je cherche un moyen (si c'est même vrai) de réfuter cette hypothèse généralisée. Je me rends compte qu'il serait impossible de prédire le résultat exact pour nous sans faire tout le travail et le profiler par la suite.
Quoi qu'il en soit, merci pour toutes vos excellentes réponses et votre aide. N'hésitez pas à ajouter autre chose :).
floataugmente la vitesse, mais ce doublen'est généralement pas le cas.
addlremplacé parfadd, par exemple). La seule façon d'obtenir une bonne mesure est d'obtenir une partie essentielle de votre programme réel et de profiler différentes versions de celui-ci. Malheureusement, cela peut être assez difficile sans utiliser des tonnes d'efforts. Peut-être que nous dire le matériel cible et votre compilateur aiderait au moins les gens à vous donner une expérience préexistante, etc. À propos de votre utilisation d'entiers, je suppose que vous pourriez créer une sorte defixed_pointclasse de modèle qui faciliterait énormément ce travail.