La Performance de types intégrés: char vs court vs int ou float vs double

absolument.

tout d'abord, bien sûr, cela dépend entièrement de l'architecture CPU en question.

cependant, les types à virgule intégrale et à virgule flottante sont traités très différemment, de sorte que ce qui suit est presque toujours le cas:

• pour les opérations simples, les types intégraux sont fast . Par exemple, l'addition d'entier a souvent seulement la latence d'un cycle simple, et la multiplication d'entier est typiquement environ 2 à 4 cycles, IIRC.
Les types à virgule flottante
• utilisés pour effectuer beaucoup plus lent. Sur les CPU d'aujourd'hui, cependant, ils ont un excellent débit, et une Chaque unité de virgule flottante peut habituellement retirer une opération par cycle, conduisant à la même (ou similaire) débit que pour les opérations entières. Cependant, la latence est généralement pire. L'addition en virgule flottante a souvent une latence autour de 4 cycles (vs 1 pour les ints).
• pour certaines opérations complexes, la situation est différent, ou même inversé. Par exemple, la division sur FP peut avoir moins de latence que pour les entiers, simplement parce que l'opération est complexe à mettre en œuvre dans les deux cas, mais il est plus souvent utile sur les valeurs FP, donc plus d'effort (et transistors) peut être dépensé en optimisant ce cas.

sur certains CPU, les doubles peuvent être significativement plus lents que les flotteurs. Sur certaines architectures, il n'y a pas de matériel dédié pour les doubles, manipulé en passant deux morceaux de la taille d'un flotteur à travers, vous donnant un pire débit et deux fois la latence. Sur d'autres (le x86 FPU, par exemple), les deux types sont convertis au même format interne 80-bit floating point, dans le cas de x86), donc la performance est identique. Sur d'autres encore, à la fois float et double ont un support matériel adéquat, mais parce que float a moins de bits, il peut être fait un peu plus rapidement, réduisant typiquement la latence un peu par rapport aux opérations doubles.

Responsabilité: Tous les temps mentionnés et les caractéristiques sont juste tirés de la mémoire. Je n'ai pas l'air de tout ça, de sorte qu'il peut être mauvais. ;)

pour différents types d'entiers, la réponse varie énormément en fonction de l'architecture CPU. L'architecture x86, en raison de sa longue histoire alambiquée, doit supporter les opérations 8, 16, 32 (et aujourd'hui 64) bits nativement, et en général, ils sont tous aussi rapides ( ils utilisent essentiellement le même matériel, et juste zéro sur les bits supérieurs que nécessaire.)

cependant, sur D'autres CPU, les types de données plus petits qu'un int peuvent être plus coûteux à charger/stocker (écrire un octet en mémoire pourrait devoir être fait en chargeant le mot entier de 32 bits dans lequel il est situé, et puis faire le masquage de bit pour mettre à jour le octet simple dans un registre, et puis écrire le mot entier retour). De même, pour les types de données plus grands que int , certains CPU peuvent avoir à diviser l'opération en deux, chargement / stockage/calcul des moitiés inférieure et supérieure séparément.

mais sur x86, la réponse est que la plupart du temps ça n'a pas d'importance. Pour des raisons historiques, le CPU doit avoir un support assez robuste pour chaque type de données. Donc la seule différence que vous êtes susceptible de remarquer est que les ops à virgule flottante ont plus de latence (mais un débit similaire, donc ils ne sont pas plus lent en soi, au moins si vous écrivez votre code correctement)

Je ne pense pas que quelqu'un ait mentionné les règles de promotion des entiers. En standard c / c++, aucune opération ne peut être effectuée sur un type plus petit que int . Si char ou short sont plus petits que int sur la plate-forme actuelle, ils sont implicitement promus à int (qui est une source majeure de bogues). Le compilateur est tenu de faire cette promotion implicite, il n'y a aucun moyen de l'contourner sans violer la norme.

les promotions integer signifient qu'aucune opération (addition, bitwise, logical etc etc) dans la langue peut se produire sur un type entier plus petit que int. Ainsi, les opérations sur char/short/int sont généralement aussi rapides que les premières sont promues sur char / short / int.

et en plus des promotions integer, il y a les" conversions arithmétiques habituelles", ce qui signifie que C s'efforce de faire les deux opérandes du même type, en convertissant l'un d'eux au plus grand des deux, s'ils sont différents.

cependant, le CPU peut effectuer diverses opérations de chargement / stockage sur 8, 16, 32 etc niveau. Sur les architectures 8 et 16 bits, cela signifie souvent que les types 8 et 16 bits sont plus rapides malgré les promotions integer. Sur un CPU 32 bits, cela signifie Peut-être que les petits types sont plus lents , parce qu'il veut que tout soit parfaitement aligné en morceaux 32 bits. Les compilateurs 32 bits optimisent généralement pour la vitesse et attribuent des types entiers plus petits dans l'espace plus grand que spécifié.

Though généralement les petits types entiers prennent bien sûr moins d'espace que les plus grands, donc si vous avez l'intention d'optimiser pour la taille de la RAM, ils sont à préférer.

y a-t-il une différence de rendement entre l'arithmétique intégrale et l'arithmétique à virgule flottante?

Oui. Cependant, ceci est très spécifique à la plateforme et au CPU. Différentes plateformes peuvent effectuer différentes opérations arithmétiques à différentes vitesses.

cela dit, la réponse en question était un peu plus précise. pow() est une routine à usage général qui fonctionne sur des valeurs doubles. En le nourrissant entier valeurs, il fait toujours tout le travail qui serait nécessaire pour manipuler les exposants non-entiers. L'utilisation de la multiplication directe contourne une grande partie de la complexité, qui est là où la vitesse entre en jeu. Ce n'est vraiment pas un problème (tellement) de différents types, mais plutôt de contourner une grande quantité de code complexe requis pour faire fonction pow avec n'importe quel exposant.

Dépend de la composition du processeur et de la plate-forme.

les plates-formes qui ont un coprocesseur à virgule flottante peuvent être plus lentes que l'arithmétique intégrale en raison du fait que les valeurs doivent être transférées vers et depuis le coprocesseur.

si le traitement en virgule flottante est au cœur du processeur, le temps d'exécution peut être négligeable.

si les calculs en virgule flottante sont émulés par un logiciel, alors l'arithmétique intégrale sera plus rapide.

dans le doute, profil.

obtenir la programmation fonctionne correctement et robuste avant d'optimiser.

La première réponse ci-dessus est grande et j'ai copié un petit bloc de travers à la suite double (car c'est là que j'ai fini premier).

est-ce que "char" et "small int"sont plus lents que "int"?

j'aimerais vous proposer le code suivant qui permet d'affecter, d'initialiser et de faire de l'arithmétique sur les différentes tailles d'entiers:

#include <iostream>

#include <windows.h>

using std::cout; using std::cin; using std::endl;

LARGE_INTEGER StartingTime, EndingTime, ElapsedMicroseconds;
LARGE_INTEGER Frequency;

void inline showElapsed(const char activity [])
{
    QueryPerformanceCounter(&EndingTime);
    ElapsedMicroseconds.QuadPart = EndingTime.QuadPart - StartingTime.QuadPart;
    ElapsedMicroseconds.QuadPart *= 1000000;
    ElapsedMicroseconds.QuadPart /= Frequency.QuadPart;
    cout << activity << " took: " << ElapsedMicroseconds.QuadPart << "us" << endl;
}

int main()
{
    cout << "Hallo!" << endl << endl;

    QueryPerformanceFrequency(&Frequency);

    const int32_t count = 1100100;
    char activity[200];

    //-----------------------------------------------------------------------------------------//
    sprintf_s(activity, "Initialise & Set %d 8 bit integers", count);
    QueryPerformanceCounter(&StartingTime);

    int8_t *data8 = new int8_t[count];
    for (int i = 0; i < count; i++)
    {
        data8[i] = i;
    }
    showElapsed(activity);

    sprintf_s(activity, "Add 5 to %d 8 bit integers", count);
    QueryPerformanceCounter(&StartingTime);

    for (int i = 0; i < count; i++)
    {
        data8[i] = i + 5;
    }
    showElapsed(activity);
    cout << endl;
    //-----------------------------------------------------------------------------------------//

    //-----------------------------------------------------------------------------------------//
    sprintf_s(activity, "Initialise & Set %d 16 bit integers", count);
    QueryPerformanceCounter(&StartingTime);

    int16_t *data16 = new int16_t[count];
    for (int i = 0; i < count; i++)
    {
        data16[i] = i;
    }
    showElapsed(activity);

    sprintf_s(activity, "Add 5 to %d 16 bit integers", count);
    QueryPerformanceCounter(&StartingTime);

    for (int i = 0; i < count; i++)
    {
        data16[i] = i + 5;
    }
    showElapsed(activity);
    cout << endl;
    //-----------------------------------------------------------------------------------------//

    //-----------------------------------------------------------------------------------------//    
    sprintf_s(activity, "Initialise & Set %d 32 bit integers", count);
    QueryPerformanceCounter(&StartingTime);

    int32_t *data32 = new int32_t[count];
    for (int i = 0; i < count; i++)
    {
        data32[i] = i;
    }
    showElapsed(activity);

    sprintf_s(activity, "Add 5 to %d 32 bit integers", count);
    QueryPerformanceCounter(&StartingTime);

    for (int i = 0; i < count; i++)
    {
        data32[i] = i + 5;
    }
    showElapsed(activity);
    cout << endl;
    //-----------------------------------------------------------------------------------------//

    //-----------------------------------------------------------------------------------------//
    sprintf_s(activity, "Initialise & Set %d 64 bit integers", count);
    QueryPerformanceCounter(&StartingTime);

    int64_t *data64 = new int64_t[count];
    for (int i = 0; i < count; i++)
    {
        data64[i] = i;
    }
    showElapsed(activity);

    sprintf_s(activity, "Add 5 to %d 64 bit integers", count);
    QueryPerformanceCounter(&StartingTime);

    for (int i = 0; i < count; i++)
    {
        data64[i] = i + 5;
    }
    showElapsed(activity);
    cout << endl;
    //-----------------------------------------------------------------------------------------//

    getchar();
}


/*
My results on i7 4790k:

Initialise & Set 1100100 8 bit integers took: 444us
Add 5 to 1100100 8 bit integers took: 358us

Initialise & Set 1100100 16 bit integers took: 666us
Add 5 to 1100100 16 bit integers took: 359us

Initialise & Set 1100100 32 bit integers took: 870us
Add 5 to 1100100 32 bit integers took: 276us

Initialise & Set 1100100 64 bit integers took: 2201us
Add 5 to 1100100 64 bit integers took: 659us
*/

mes résultats en MSVC sur i7 4790k:

Initialise & Set 1100100 8 bits entiers pris: 444us

Ajouter 5 à 1100100 8 bits entiers pris: 358us

Initialise & Set 1100100 entiers 16 bits pris: 666us

Ajouter 5 à 1100100 entiers de 16 bits pris: 359us

Initialise & Set 1100100 32 bits entiers pris: 870us

Ajouter 5 à 1100100 entiers 32 bits pris: 276us

Initialise & Set 1100100 64 bit entiers pris: 2201us

Ajouter 5 à 1100100 64 bits entiers pris: 659us

non, pas vraiment. Cela dépend bien sûr du CPU et du compilateur, mais la différence de performance est généralement négligeable - s'il y en a même.

il y a certainement une différence entre l'arithmétique flottante et l'arithmétique entière. Selon le matériel spécifique du CPU et les micro-instructions, vous obtenez des performances et/ou une précision différentes. Bons termes google pour les descriptions précises (Je ne sais pas non plus exactement):

FPU x87 MMX SSE

en ce qui concerne la taille des entiers, il est préférable d'utiliser la plateforme / architecture word size (ou le double que), ce qui revient à un int32_t sur x86 et int64_t sur x86_64. Certains processeurs peuvent avoir des instructions intrinsèques qui traitent plusieurs de ces valeurs à la fois (comme SSE (floating point) et MMX), ce qui accélérera les additions ou les multiplications parallèles.

généralement, les mathématiques entières sont plus rapides que les mathématiques à virgule flottante. C'est parce que les maths entières impliquent des calculs plus simples. Cependant, dans la plupart des opérations que nous parlons moins d'une douzaine d'horloges. Pas des millimètres, des micros, des nanos ou des tiques; des horloges. Ceux qui se produisent entre 2-3 milliards de fois par seconde dans les noyaux modernes. En outre, depuis le 486 beaucoup de noyaux ont un ensemble D'Unités de traitement flottantes ou FPUs, qui sont câblés dur pour effectuer l'arithmétique flottante efficacement, et souvent en parallèle avec le CPU.

en raison de ces, bien que techniquement, il est plus lent, les calculs à virgule flottante sont encore si rapide que toute tentative de chronométrer la différence aurait plus d'erreur inhérente dans le mécanisme de synchronisation et la programmation de thread qu'il ne faut réellement pour effectuer le calcul. Utilisez les ints quand vous le pouvez, mais comprenez quand vous ne le pouvez pas, et ne vous inquiétez pas trop au sujet de la vitesse de calcul relative.