Bonsoir,

Il y a peu de temps, je me suis dit que j'allais me remettre aux opérateurs bit à bit. Après avoir lu quelques billets de blog sur les effets néfastes des branchements conditionnels, j'ai essayé de reproduire ce mécanisme de condition avec ces opérateurs bas niveaux.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdint.h>
 
/*
 * Evaluate the expression `expr'. If it's true, return `a' ; else, return `b'.
 * This function doesn't use any conditionnal or unconditionnal branches,
 * therefore it should go faster than an habitual function-like if the macro
 * `CODE_OPTIMIZE' is defined.
 */
static inline uint32_t test(_Bool expr, uint32_t a, uint32_t b)
{
#ifdef CODE_OPTIMIZE
	uint32_t mask = (uint32_t)(((int32_t) -expr) >> 31);
	return (a & mask) | (b & ~mask);
#else
	return expr ? a : b;
#endif
}
Si on met de côté les commentaires dans mon anglais grisonnant ainsi que la relative illisibilité du code, je me retrouve quand même avec des résultats probants sur plusieurs benchmark.

Ce sujet n'est donc pas réellement une question, mais plutôt une demande de confirmation, voire d'améliorations de ce code qui semble aller plus vite lorsque la constante CODE_OPTIMIZE est définie.

Et, sinon, dans ce cas-là, pourquoi utiliser les ternaires par exemple (qui a beau être une implémentation native du langage...), dont on pourrait, par exemple, recoder le fonctionnement grâce à des macros hideuses de génération de code. (mis à part le problème de flexibilité dû à l'utilisation des entiers de taille fixe, qui peut être contourné)

Bonne soirée à vous et merci pour votre lecture et/ou pour votre participation.