Il s'agit d'un suivi de la discussion avec @RocketRoy concernant sa réponse , mais il pourrait être utile à quiconque souhaite comparer ces résultats.
tl; dr D'après ce que j'ai vu, l'approche de Roy ( (0xFFFFFFFF == (x | 0xFFFFFFFE)) n'est pas complètement optimisée pour x & 1être l' modapproche, mais dans la pratique, les temps d'exécution devraient se révéler égaux dans tous les cas.
Donc, j'ai d'abord comparé la sortie compilée à l'aide de l' explorateur de compilateur :
Fonctions testées:
int isOdd_mod(unsigned x) {
return (x % 2);
}
int isOdd_and(unsigned x) {
return (x & 1);
}
int isOdd_or(unsigned x) {
return (0xFFFFFFFF == (x | 0xFFFFFFFE));
}
CLang 3.9.0 avec -O3:
isOdd_mod(unsigned int): # @isOdd_mod(unsigned int)
and edi, 1
mov eax, edi
ret
isOdd_and(unsigned int): # @isOdd_and(unsigned int)
and edi, 1
mov eax, edi
ret
isOdd_or(unsigned int): # @isOdd_or(unsigned int)
and edi, 1
mov eax, edi
ret
GCC 6.2 avec -O3:
isOdd_mod(unsigned int):
mov eax, edi
and eax, 1
ret
isOdd_and(unsigned int):
mov eax, edi
and eax, 1
ret
isOdd_or(unsigned int):
or edi, -2
xor eax, eax
cmp edi, -1
sete al
ret
Chapeau à CLang, il s'est rendu compte que les trois cas sont fonctionnellement égaux. Cependant, l'approche de Roy n'est pas optimisée dans GCC, donc YMMV.
C'est similaire avec Visual Studio; en inspectant le démontage Release x64 (VS2015) pour ces trois fonctions, j'ai pu voir que la partie de comparaison est égale pour les cas "mod" et "et", et légèrement plus grande pour le cas Roy ou ":
// x % 2
test bl,1
je (some address)
// x & 1
test bl,1
je (some address)
// Roy's bitwise or
mov eax,ebx
or eax,0FFFFFFFEh
cmp eax,0FFFFFFFFh
jne (some address)
Cependant, après avoir exécuté un benchmark réel pour comparer ces trois options (mod simple, bit à bit ou, bit à bit et), les résultats étaient complètement égaux (encore une fois, Visual Studio 2005 x86 / x64, version Release, aucun débogueur attaché).
L'assemblage de version utilise l' testinstruction pour andet les modcas, tandis que le cas de Roy utilise l' cmp eax,0FFFFFFFFhapproche, mais il est fortement déroulé et optimisé, donc il n'y a pas de différence dans la pratique.
Mes résultats après 20 exécutions (i7 3610QM, plan d'alimentation Windows 10 défini sur Haute performance):
[Test: Plain mod 2] TEMPS MOYEN: 689,29 ms (Diff relative: + 0,000%)
[Test: au niveau du bit ou] TEMPS MOYEN: 689,63 ms (diff. Relative: + 0,048%)
[Test: au niveau du bit et] TEMPS MOYEN: 687,80 ms (diff. Relative: -0,217%)
La différence entre ces options est inférieure à 0,3%, il est donc assez évident que l'assemblage est égal dans tous les cas.
Voici le code si quelqu'un veut essayer, avec une mise en garde que je ne l'ai testé que sur Windows (vérifiez le #if LINUXconditionnel pour la get_timedéfinition et implémentez-le si nécessaire, tiré de cette réponse ).
#include <stdio.h>
#if LINUX
#include <sys/time.h>
#include <sys/resource.h>
double get_time()
{
struct timeval t;
struct timezone tzp;
gettimeofday(&t, &tzp);
return t.tv_sec + t.tv_usec*1e-6;
}
#else
#include <windows.h>
double get_time()
{
LARGE_INTEGER t, f;
QueryPerformanceCounter(&t);
QueryPerformanceFrequency(&f);
return (double)t.QuadPart / (double)f.QuadPart * 1000.0;
}
#endif
#define NUM_ITERATIONS (1000 * 1000 * 1000)
// using a macro to avoid function call overhead
#define Benchmark(accumulator, name, operation) { \
double startTime = get_time(); \
double dummySum = 0.0, elapsed; \
int x; \
for (x = 0; x < NUM_ITERATIONS; x++) { \
if (operation) dummySum += x; \
} \
elapsed = get_time() - startTime; \
accumulator += elapsed; \
if (dummySum > 2000) \
printf("[Test: %-12s] %0.2f ms\r\n", name, elapsed); \
}
void DumpAverage(char *test, double totalTime, double reference)
{
printf("[Test: %-12s] AVERAGE TIME: %0.2f ms (Relative diff.: %+6.3f%%)\r\n",
test, totalTime, (totalTime - reference) / reference * 100.0);
}
int main(void)
{
int repeats = 20;
double runningTimes[3] = { 0 };
int k;
for (k = 0; k < repeats; k++) {
printf("Run %d of %d...\r\n", k + 1, repeats);
Benchmark(runningTimes[0], "Plain mod 2", (x % 2));
Benchmark(runningTimes[1], "Bitwise or", (0xFFFFFFFF == (x | 0xFFFFFFFE)));
Benchmark(runningTimes[2], "Bitwise and", (x & 1));
}
{
double reference = runningTimes[0] / repeats;
printf("\r\n");
DumpAverage("Plain mod 2", runningTimes[0] / repeats, reference);
DumpAverage("Bitwise or", runningTimes[1] / repeats, reference);
DumpAverage("Bitwise and", runningTimes[2] / repeats, reference);
}
getchar();
return 0;
}