Quelle est l'utilisation excessive des macros «probable» et «improbable»?

Les macros souvent connues sous le nom de likelyet unlikelyaident le compilateur à savoir si un iffichier va généralement être entré ou ignoré. Son utilisation entraîne des améliorations de performances (plutôt mineures).

J'ai commencé à les utiliser récemment et je ne sais pas à quelle fréquence ces conseils devraient être utilisés. Je l'utilise actuellement avec des vérifications d'erreurs if, qui sont généralement marquées comme unlikely. Par exemple:

mem = malloc(size);
if (unlikely(mem == NULL))
  goto exit_no_mem;

Cela semble correct, mais la vérification des erreurs ifse produit assez souvent et, par conséquent, l'utilisation desdites macros.

Ma question est, est - il trop d'avoir likelyet unlikelymacros sur chaque vérification des erreurs if?

Pendant que nous y sommes, quels autres endroits sont-ils souvent utilisés?

Dans mon utilisation actuelle, c'est dans une bibliothèque qui fait une abstraction du sous-système en temps réel, donc les programmes deviendraient portables entre RTAI, QNX et d'autres. Cela dit, la plupart des fonctions sont plutôt petites et appellent directement une ou deux autres fonctions. Beaucoup sont même des static inlinefonctions.

Donc, tout d'abord, ce n'est pas une application que je pourrais profiler. Il n'est pas logique d '«identifier les goulots d'étranglement» car c'est une bibliothèque, pas une application autonome.

Deuxièmement, c'est un peu comme "Je sais que c'est peu probable, autant le dire au compilateur". Je n'essaie pas activement d'optimiser le if.

Avez-vous tellement besoin de performances que vous êtes prêt à polluer votre code avec cela? C'est une optimisation mineure.

• Le code s'exécute-t-il en boucle serrée?
• Votre application a-t-elle des problèmes de performances?
• Avez-vous profilé votre application et déterminé que cette boucle particulière coûte beaucoup de temps CPU?

À moins que vous ne puissiez répondre yesà tout ce qui précède, ne vous embêtez pas avec des trucs comme ça.

Modifier: en réponse à la modification. Même lorsque vous ne pouvez pas profiler, vous pouvez généralement estimer les points d'accès. Une fonction d'allocation de mémoire appelée par tout le monde est un bon candidat, d'autant plus qu'elle ne nécessite qu'une seule utilisation de la macro pour fonctionner pour l'ensemble de la bibliothèque.

Si vous écrivez pour x86 / x64 (et que vous n'utilisez pas de processeurs vieux de 20 ans), le gain de performances de l'utilisation de __builtin_expect () sera négligeable le cas échéant. La raison en est que les processeurs x86 / x64 modernes (mais pas sûrs à 100% d'Atom), ont une prédiction de branche dynamique, donc essentiellement le CPU "apprend" la branche qui est prise le plus souvent. Bien sûr, ces informations ne peuvent être stockées que pour un nombre limité de succursales, cependant, il n'y a que deux cas possibles. Si (a) c'est une branche "fréquemment utilisée", alors votre programme bénéficiera de cette prédiction de branche dynamique, et si (b) c'est une branche "rare", vous ne verrez pas vraiment de performances réalistes affectées par des erreurs de prédiction dans de telles branches rares (20 cycles CPU de mauvaise prévision de branche ne sont pas TROP mauvais si cela se produit une fois dans une lune bleue).

NB: cela n'implique PAS que sur les x86 / x64 modernes, l'importance de la mauvaise prédiction de branche a diminué: toute branche avec 50-50 chance de saut-nojump encourra toujours une pénalité (IIRC 10-20 cycles CPU), donc dans les boucles internes, les branches peuvent doivent encore être évités. C'est seulement l'importance de __builtin_expect () sur x86 / x64 qui a diminué (IIRC, il y a environ 10-15 ans) - principalement à cause de la prédiction de branche dynamique.

NB2: pour les autres plateformes au-delà de x86 / x64, YMMV.