Este es un seguimiento de la discusión con @RocketRoy con respecto a su respuesta , pero podría ser útil para cualquiera que quiera comparar estos resultados.
tl; dr Por lo que he visto, el enfoque de Roy ( (0xFFFFFFFF == (x | 0xFFFFFFFE)) no está completamente optimizado x & 1como el modenfoque, pero en la práctica los tiempos de ejecución deberían ser iguales en todos los casos.
Entonces, primero comparé la salida compilada usando Compiler Explorer :
Funciones probadas:
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 con -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 con -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
Gracias a CLang, se dio cuenta de que los tres casos son funcionalmente iguales. Sin embargo, el enfoque de Roy no está optimizado en GCC, por lo que YMMV.
Es similar con Visual Studio; Al inspeccionar la versión de desensamblaje x64 (VS2015) para estas tres funciones, pude ver que la parte de comparación es igual para "mod" y "y" casos, y un poco más grande para el caso de Roy "o":
// 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)
Sin embargo, después de ejecutar un punto de referencia real para comparar estas tres opciones (mod simple, bit a bit o bit a bit y), los resultados fueron completamente iguales (de nuevo, Visual Studio 2005 x86 / x64, versión de compilación, sin depurador adjunto).
El ensamblaje de lanzamiento usa las testinstrucciones andy los modcasos, mientras que el caso de Roy usa el cmp eax,0FFFFFFFFhenfoque, pero está muy desenrollado y optimizado, por lo que no hay diferencia en la práctica.
Mis resultados después de 20 ejecuciones (i7 3610QM, plan de energía de Windows 10 establecido en Alto rendimiento):
[Prueba: Mod 2 simple] TIEMPO PROMEDIO: 689.29 ms (Diferencia relativa: + 0.000%)
[Prueba: Bitwise o] TIEMPO PROMEDIO: 689,63 ms (Diferencia relativa: + 0,048%)
[Prueba: a nivel de bits y] TIEMPO PROMEDIO: 687,80 ms (diferencia relativa: -0,217%)
La diferencia entre estas opciones es inferior al 0.3%, por lo que es bastante obvio que el ensamblaje es igual en todos los casos.
Aquí está el código si alguien quiere probar, con una advertencia de que solo lo probé en Windows (verifique el #if LINUXcondicional para la get_timedefinición e impleméntelo si es necesario, tomado de esta respuesta ).
#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;
}