Est-il un compilateur astuce pour GCC pour forcer la direction de la prévision pour aller toujours une certaine façon?

La bonne façon de définir probable/peu probable macros en C++11 est le suivant:

#define LIKELY(condition) __builtin_expect(static_cast<bool>(condition), 1)
#define UNLIKELY(condition) __builtin_expect(static_cast<bool>(condition), 0)

---

Lorsque ces macros définies de cette façon:

#define LIKELY(condition) __builtin_expect(!!(condition), 1)

Qui peuvent changer le sens de if états et de briser le code. Considérons le code suivant:

#include <iostream>

struct A
{
    explicit operator bool() const { return true; }
    operator int() const { return 0; }
};

#define LIKELY(condition) __builtin_expect((condition), 1)

int main() {
    A a;
    if(a)
        std::cout << "if(a) is true\n";
    if(LIKELY(a))
        std::cout << "if(LIKELY(a)) is true\n";
    else
        std::cout << "if(LIKELY(a)) is false\n";
}

Et sa sortie:

if(a) is true
if(LIKELY(a)) is false

Comme vous pouvez le voir, la définition de la probabilité à l'aide de !! comme une troupe de bool sauts de la sémantique de if.

Le point ici n'est pas que operator int() et operator bool() devraient être liés. Ce qui est une bonne pratique.

Plutôt que l'utilisation de !!(x) au lieu de static_cast<bool>(x) perd le contexte de C++11 contextuelle conversions.

gcc a long __builtin_attendent (longue exp, longtemps c) (accent mine):

Vous pouvez utiliser __builtin_s'attendre à fournir le compilateur de la direction
la prédiction de l'information. En général, vous devriez préférer l'utilisation réelle
profil de retour pour ce (-fprofile-arcs), que les programmeurs sont
notoirement mauvais pour prédire la façon dont leurs programmes effectuent.
Cependant, il existe des applications dans lesquelles ces données sont difficiles à recueillir.

La valeur de retour est la valeur de exp, ce qui devrait être une partie intégrante
de l'expression. La sémantique de l'élément sont qu'il est prévu que
exp == c. Par exemple:

if (__builtin_expect (x, 0))
   foo ();

indique que nous ne nous attendons pas à appeler foo, puisque nous nous attendons à x d'être
zéro. Depuis que vous êtes limité à partie intégrante des expressions pour l'exp, vous
devrait utiliser des constructions telles que les

if (__builtin_expect (ptr != NULL, 1))
   foo (*ptr);

lors de l'essai de pointeur ou de valeurs à virgule flottante.

Que les notes de documentation vous devez vous préférez utiliser le profil réel de la rétroaction et cet article montre un exemple pratique de cette et comment, dans leur cas, au moins, finit par être une amélioration à l'aide __builtin_expect. Voir aussi Comment utiliser le profil guidée des optimisations dans g++?.

On peut aussi trouver une Le noyau Linux débutants article sur le kernel macros probable() et rare() qui utilisent cette fonctionnalité:

#define likely(x)       __builtin_expect(!!(x), 1)
#define unlikely(x)     __builtin_expect(!!(x), 0)

Note le !! utilisé dans la macro on peut trouver l'explication de ce phénomène dans Pourquoi utiliser !!(condition) au lieu de (condition)?.

Tout simplement parce que cette technique est utilisée dans le noyau Linux ne veut pas dire qu'il fait toujours sens pour l'utiliser. Nous pouvons voir à partir de cette question que j'ai récemment répondu à différence entre les performances de la fonction lors du passage de paramètre en tant que moment de la compilation constante ou variable que beaucoup roulé à la main optimisations techniques ne fonctionnent pas dans le cas général. Nous avons besoin de code de profil attentivement afin de comprendre si une technique est efficace. De nombreuses techniques anciennes peuvent ne pas être pertinents moderne, avec des optimisations du compilateur.

Remarque, bien que les objets internes ne sont pas portables clang prend également en charge __builtin_attendent.

Également sur certains architectures il ne peut faire une différence.

Que les autres réponses ont suffisamment suggéré, vous pouvez utiliser __builtin_expect pour donner le compilateur un indice sur la façon d'organiser le code assembleur. Comme les docs officielles, dans la plupart des cas, l'assembleur intégré dans votre cerveau ne sera pas aussi bon que celui conçu par l'équipe de GCC. C'est toujours mieux d'utiliser le profil réel de données afin d'optimiser votre code, plutôt que de deviner.

Le long des lignes similaires, mais pas encore mentionné, est un GCC-de manière spécifique pour forcer le compilateur à générer du code sur un "froid" chemin d'accès. Cela implique l'utilisation de la noinline et cold des attributs, qui font exactement ce que ils semblent comme ils le font. Ces attributs ne peuvent être appliquées à des fonctions, mais avec le C++11, vous pouvez déclarer inline lambda fonctions et ces deux attributs peuvent également être appliqué à des fonctions lambda.

Bien que cela tombe toujours dans la catégorie générale d'un micro-optimisation, et ainsi, la norme s'applique—test ne suppose—j'ai l'impression que c'est plus utile que __builtin_expect. À peine toutes les générations de la x86 processeur de l'utilisation de la branche de prédiction des indices (référence), de sorte que la seule chose que vous allez être en mesure d'affecter de toute façon, est de l'ordre de l'assemblée le code. Puisque vous savez ce qui est de l'erreur de manipulation ou de "cas limite" de code, vous pouvez utiliser cette annotation pour s'assurer que le compilateur ne pourra jamais prédire une branche et il se lier à l'écart de la "hot" dans le code lors de l'optimisation de la taille.

Exemple d'utilisation:

void FooTheBar(void* pFoo)
{
    if (pFoo == nullptr)
    {
        //Oh no! A null pointer is an error, but maybe this is a public-facing
        //function, so we have to be prepared for anything. Yet, we don't want
        //the error-handling code to fill up the instruction cache, so we will
        //force it out-of-line and onto a "cold" path.
        [&]() __attribute__((noinline,cold)) {
            HandleError(...);
        }();
    }

    //Do normal stuff
    ⋮
}

Encore mieux, GCC mettra automatiquement ignorer cela en faveur de profil de commentaires quand il est disponible (par exemple, lors de la compilation avec -fprofile-use).

Voir la documentation officielle ici: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#Common-Function-Attributes

En ce qui concerne l'OP, il n'y a aucune façon de GCC pour dire que le processeur à toujours assumer la direction est ou n'est pas prise. Ce que vous avez est __builtin_attendent, ce qui fait ce que d'autres disent qu'il n'. En outre, je pense que vous ne voulez pas dire que le processeur de savoir si la branche est prise ou pas toujours. Aujourd'hui, les processeurs, tels que l'architecture Intel peut reconnaître assez complexe de motifs et de s'adapter efficacement.

Cependant, il ya des moments que vous voulez prendre le contrôle de savoir si par défaut une branche est prévu prises ou non: Lorsque vous connaissez le code sera appelé "froid" à l'égard de la ramification de la statistique.

Un exemple concret: la gestion des exceptions code. Par définition, le code de gestion qui va arriver exceptionnellement, mais peut-être lorsqu'il se produit une performance maximale est souhaitée (il y a peut être une erreur critique à prendre en charge hors dès que possible), donc vous pouvez contrôler le défaut de prévision.

Un autre exemple: Vous pouvez classer vos commentaires et de sauter dans le code qui gère le résultat de votre classification. S'il existe de nombreuses classifications, le processeur peut collecter des statistiques, mais les perdre parce que le même classement ne se fait pas assez vite et la prédiction de ressources sont consacrées à récemment appelé code. Je souhaite qu'il y aurait une primitive de dire que le processeur "merci de ne pas consacrer de prédiction des ressources de ce code," le chemin parfois, vous pouvez dire "ne pas mettre en cache ce".