Это продолжение обсуждения с @RocketRoy относительно его ответа , но оно может быть полезно всем, кто хочет сравнить эти результаты.
tl; dr Из того, что я видел, подход Роя ( (0xFFFFFFFF == (x | 0xFFFFFFFE)) не полностью оптимизирован x & 1как modподход, но на практике время выполнения должно быть одинаковым во всех случаях.
Итак, сначала я сравнил скомпилированный вывод, используя Compiler Explorer :
Проверенные функции:
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 с -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 с -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
Сняв шляпу до CLang, он понял, что все три случая функционально равны. Тем не менее, подход Роя не оптимизирован в GCC, поэтому YMMV.
Это похоже на Visual Studio; Изучив разборку Выпуска x64 (VS2015) для этих трех функций, я увидел, что часть сравнения равна для случаев "mod" и "and", и немного больше для случая "Roy's" или ":
// 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)
Однако после запуска фактического теста для сравнения этих трех параметров (обычный мод, поразрядный или, поразрядный и) результаты были полностью равны (опять же, Visual Studio 2005 x86 / x64, сборка выпуска, отладчик не подключен).
Сборка релиза использует testинструкцию для случаев andи modслучаев, в то время как случай Роя использует cmp eax,0FFFFFFFFhподход, но он в значительной степени развернут и оптимизирован, поэтому на практике нет никакой разницы.
Мои результаты после 20 запусков (i7 3610QM, план питания Windows 10 установлен на High Performance):
[Тест: Обычный мод 2] Среднее время: 689,29 мс (Относительная разница: + 0,000%)
[Тест: побитовый или] СРЕДНЕЕ ВРЕМЯ: 689,63 мс (Относительная разница: + 0,048%)
[Тест: Побитовый и] СРЕДНЕЕ ВРЕМЯ: 687.80 мс (Относительная разница: -0.217%)
Разница между этими вариантами составляет менее 0,3%, поэтому очевидно, что сборка одинакова во всех случаях.
Вот код, если кто-то хочет попробовать, с оговоркой, что я проверил его только в Windows (проверьте #if LINUXусловное get_timeопределение и реализуйте его, если необходимо, взято из этого ответа ).
#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;
}