performance des entiers non signés vs signés

Question

Existe-t-il un gain ou une perte de performance en utilisant des entiers non signés sur des entiers signés?

Si oui, est-ce que cela va pour court et long aussi?

Answer 1

La Division par puissances de 2 est plus rapide avec unsigned int, car il peut être optimisé en un seul quart de travail à l'instruction. Avec signed int, il faut généralement plus d'instructions machine, parce que les cycles de division vers zéro, mais en se décalant sur la droite des tours vers le bas. Exemple:

int foo(int x, unsigned y)
{
    x /= 8;
    y /= 8;
    return x + y;
}

Voici la x partie (signé) de la division:

movl 8(%ebp), %eax
leal 7(%eax), %edx
testl %eax, %eax
cmovs %edx, %eax
sarl $3, %eax

Et voici la y partie (non signé) de la division:

movl 12(%ebp), %edx
shrl $3, %edx

Answer 2

En C ++ (et C), le débordement d'entier signé n'est pas défini, alors que le débordement d'entier non signé est défini pour être bouclé. Notez que, par exemple, dans gcc, vous pouvez utiliser l’option -fwrapv pour définir le débordement signé (à boucler).

Un dépassement d'entier signé non défini permet au compilateur de supposer que les dépassements ne se produisent pas, ce qui peut créer des opportunités d'optimisation. Voir par exemple cet article de blog pour la discussion.

Answer 3

unsigned conduit à la même ou meilleure performance qu' signed. Quelques exemples:

• La Division par une constante qui est une puissance de 2 (voir aussi la réponse de FredOverflow)
• La Division par un nombre constant (par exemple, mon compilateur met en œuvre la division par 13 à l'aide de 2 asm instructions pour non signé, et 6 instructions pour la signature)
• Vérifier si un nombre est pair (je n'ai aucune idée de pourquoi mon MS compilateur Visual Studio met en œuvre, avec 4 instructions d' signed nombres; gcc, il le fait avec 1 de l'instruction, tout comme dans l' unsigned des cas)

short entraîne généralement la même ou de moins bonnes performances que int (en supposant sizeof(short) < sizeof(int)). La dégradation des performances qui se passe lorsque vous affectez un résultat d'une opération arithmétique (qui est habituellement int, jamais short) à une variable de type short, ce qui est stockée dans le registre du processeur (qui est aussi de type int). Toutes les conversions d' short de int prennent du temps et sont ennuyeux.

Remarque: certains des Dsp ont multiplication rapide des instructions pour l' signed short type; dans ce cas précis, short plus rapide que de l' int.

Quant à la différence entre int et long, je ne peux que deviner (je ne suis pas familier avec les architectures 64 bits). Bien sûr, si int et long ont la même taille (sur les plates-formes 32 bits), leur performance est aussi le même.

Answer 4

Cela dépendra de la mise en œuvre exacte. Dans la plupart des cas, il n'y aura aucune différence cependant. Si vous y tenez vraiment, vous devez essayer toutes les variantes que vous envisagez et mesurer les performances.

Answer 5

Cela dépend beaucoup du processeur spécifique.

Sur la plupart des processeurs, il existe des instructions pour l'arithmétique signée et non signée, ainsi la différence entre l'utilisation d'entiers signés et non signés est déterminée par celle utilisée par le compilateur.

Si l'un des deux est plus rapide, il est totalement spécifique au processeur, et la différence est probablement minime, si elle existe.