Puis-je indiquer l'optimiseur en donnant la plage d'un entier?

J'utilise un inttype pour stocker une valeur. Selon la sémantique du programme, la valeur varie toujours dans une très petite plage (0 - 36), et int(pas a char) n'est utilisée qu'en raison de l'efficacité du processeur.

Il semble que de nombreuses optimisations arithmétiques spéciales puissent être effectuées sur une si petite plage d'entiers. De nombreux appels de fonction sur ces nombres entiers peuvent être optimisés en un petit ensemble d'opérations «magiques», et certaines fonctions peuvent même être optimisées dans des recherches de table.

Alors, est-il possible de dire au compilateur que intc'est toujours dans cette petite plage, et est-il possible pour le compilateur de faire ces optimisations?

Oui c'est possible. Par exemple, car gccvous pouvez utiliser __builtin_unreachablepour informer le compilateur des conditions impossibles, comme ceci:

if (value < 0 || value > 36) __builtin_unreachable();

Nous pouvons envelopper la condition ci-dessus dans une macro:

#define assume(cond) do { if (!(cond)) __builtin_unreachable(); } while (0)

Et utilisez-le comme ceci:

assume(x >= 0 && x <= 10);

Comme vous pouvez le voir , gcceffectue des optimisations en fonction de ces informations:

#define assume(cond) do { if (!(cond)) __builtin_unreachable(); } while (0)

int func(int x){
    assume(x >=0 && x <= 10);

    if (x > 11){
        return 2;
    }
    else{
        return 17;
    }
}

Produit:

func(int):
    mov     eax, 17
    ret

Un inconvénient, cependant, que si votre code rompt un jour ces hypothèses, vous obtenez un comportement indéfini .

Il ne vous avertit pas lorsque cela se produit, même dans les versions de débogage. Pour déboguer / tester / attraper les bogues avec des hypothèses plus facilement, vous pouvez utiliser une macro hybride assume / assert (crédits à @David Z), comme celle-ci:

#if defined(NDEBUG)
#define assume(cond) do { if (!(cond)) __builtin_unreachable(); } while (0)
#else
#include <cassert>
#define assume(cond) assert(cond)
#endif

Dans les versions de débogage ( NDEBUG sans définition), il fonctionne comme un assertmessage d'erreur d'impression ordinaire et abortun programme d'ingénierie, et dans les versions de version, il utilise une hypothèse, produisant un code optimisé.

Notez, cependant, qu'il ne remplace pas les versions régulières assert- condreste dans les versions de version, vous ne devriez donc pas faire quelque chose comme assume(VeryExpensiveComputation()).

Il existe un support standard pour cela. Ce que vous devez faire est d'inclure stdint.h( cstdint), puis d'utiliser le type uint_fast8_t.

Cela indique au compilateur que vous n'utilisez que des nombres compris entre 0 et 255, mais qu'il est libre d'utiliser un type plus grand si cela donne un code plus rapide. De même, le compilateur peut supposer que la variable n'aura jamais une valeur supérieure à 255 et ensuite effectuer des optimisations en conséquence.

La réponse actuelle est bonne pour le cas où vous savez avec certitude quelle est la plage, mais si vous voulez toujours un comportement correct lorsque la valeur est en dehors de la plage attendue, cela ne fonctionnera pas.

Dans ce cas, j'ai trouvé que cette technique peut fonctionner:

if (x == c)  // assume c is a constant
{
    foo(x);
}
else
{
    foo(x);
}

L'idée est un compromis code-données: vous déplacez 1 bit de données (que ce soit x == c) dans la logique de contrôle .
Cela fait allusion à l'optimiseur qui xest en fait une constante connue c, l'encourageant à intégrer et à optimiser le premier appel de fooséparément du reste, peut-être assez lourdement.

Assurez-vous de factoriser le code en un seul sous foo- programme , cependant - ne dupliquez pas le code.

Exemple:

Pour que cette technique fonctionne, vous devez être un peu chanceux - il y a des cas où le compilateur décide de ne pas évaluer les choses de manière statique, et ils sont plutôt arbitraires. Mais quand ça marche, ça marche bien:

#include <math.h>
#include <stdio.h>

unsigned foo(unsigned x)
{
    return x * (x + 1);
}

unsigned bar(unsigned x) { return foo(x + 1) + foo(2 * x); }

int main()
{
    unsigned x;
    scanf("%u", &x);
    unsigned r;
    if (x == 1)
    {
        r = bar(bar(x));
    }
    else if (x == 0)
    {
        r = bar(bar(x));
    }
    else
    {
        r = bar(x + 1);
    }
    printf("%#x\n", r);
}

Utilisez simplement -O3et notez les constantes pré-évaluées 0x20et 0x30edans la sortie de l'assembleur .

Je veux juste dire que si vous voulez une solution plus standard en C ++, vous pouvez utiliser l' [[noreturn]]attribut pour écrire la vôtre unreachable.

Je vais donc réutiliser l' excellent exemple de deniss pour démontrer:

namespace detail {
    [[noreturn]] void unreachable(){}
}

#define assume(cond) do { if (!(cond)) detail::unreachable(); } while (0)

int func(int x){
    assume(x >=0 && x <= 10);

    if (x > 11){
        return 2;
    }
    else{
        return 17;
    }
}

Ce qui, comme vous pouvez le voir , donne un code presque identique:

detail::unreachable():
        rep ret
func(int):
        movl    $17, %eax
        ret

L'inconvénient est bien sûr que vous recevez un avertissement indiquant qu'une [[noreturn]]fonction retourne effectivement.