Це продовження дискусії з @RocketRoy щодо його відповіді , але це може бути корисним для всіх, хто хоче порівняти ці результати.
tl; dr З того, що я бачив, підхід Роя ( (0xFFFFFFFF == (x | 0xFFFFFFFE)) не повністю оптимізований x & 1як modпідхід, але на практиці час роботи повинен виявитися рівним у всіх випадках.
Отже, спочатку я порівняв компільований вихід за допомогою Провідника компілятора :
Функції перевірені:
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" і "і" випадків, і трохи більша для випадку Roy "або":
// 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 встановлено на високу продуктивність):
[Тест: Звичайний мод 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;
}