Jest to kontynuacja dyskusji z @RocketRoy na temat jego odpowiedzi , ale może być przydatna dla każdego, kto chce porównać te wyniki.
tl; dr Z tego, co widziałem, podejście Roya ( (0xFFFFFFFF == (x | 0xFFFFFFFE)) nie jest całkowicie zoptymalizowane x & 1jako modpodejście, ale w praktyce czasy działania powinny być takie same we wszystkich przypadkach.
Najpierw porównałem skompilowane dane wyjściowe za pomocą Eksploratora kompilatorów :
Testowane funkcje:
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 z -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 z -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
Czapki do CLanga, zdałem sobie sprawę, że wszystkie trzy przypadki są funkcjonalnie równe. Jednak podejście Roya nie jest zoptymalizowane w GCC, więc YMMV.
Podobnie jest z Visual Studio; sprawdzając wersję demontażową wydania x64 (VS2015) pod kątem tych trzech funkcji, zauważyłem, że część porównawcza jest równa dla przypadków „mod” i „i” oraz nieco większa dla przypadku „Roy” lub „”:
// 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)
Jednak po uruchomieniu rzeczywistego testu porównawczego dla porównania tych trzech opcji (zwykły mod, bitowy lub bitowy i) wyniki były całkowicie równe (ponownie, Visual Studio 2005 x86 / x64, kompilacja wydania, bez dołączonego debuggera).
Zespół wydania używa testinstrukcji andi modprzypadków, podczas gdy sprawa Roya używa tego cmp eax,0FFFFFFFFhpodejścia, ale jest mocno rozwinięta i zoptymalizowana, więc nie ma różnicy w praktyce.
Moje wyniki po 20 uruchomieniach (i7 3610QM, plan zasilania systemu Windows 10 ustawiony na wysoką wydajność):
[Test: Plain mod 2] ŚREDNI CZAS: 689,29 ms (Różnica względna: + 0,000%)
[Test: Bitowy lub] CZAS ŚREDNI: 689,63 ms (Różnica względna: + 0,048%)
[Test: Bitowy i] CZAS ŚREDNI: 687,80 ms (Różnica względna: -0,217%)
Różnica między tymi opcjami wynosi mniej niż 0,3%, więc jest raczej oczywiste, że zespół jest jednakowy we wszystkich przypadkach.
Oto kod, jeśli ktoś chce spróbować, z zastrzeżeniem, że testowałem go tylko w systemie Windows (sprawdź #if LINUXwarunek dla get_timedefinicji i zaimplementuj ją w razie potrzeby, wzięty z tej odpowiedzi ).
#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;
}