Bu, @RocketRoy ile cevabı hakkındaki tartışmanın devamı niteliğindedir. , ancak bu sonuçları karşılaştırmak isteyen herkes için yararlı olabilir.
tl; dr Gördüğüm kadarıyla, Roy'un yaklaşımı ( (0xFFFFFFFF == (x | 0xFFFFFFFE)) tamamen üzere optimize edilmemiştir x & 1olarakmod yaklaşımla, ama pratikte çalışan süreleri her durumda eşit çıkmak gerekir.
İlk olarak derlenmiş çıktıyı Compiler Explorer kullanarak karşılaştırdım :
Test edilen fonksiyonlar:
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 ile:
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
-O3 ile GCC 6.2:
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'a kadar şapkalar, üç vakanın da işlevsel olarak eşit olduğunu fark etti. Bununla birlikte, Roy'un yaklaşımı GCC'de optimize edilmediğinden YMMV.
Visual Studio ile benzer; bu üç işlev için sökme Bülteni x64 (VS2015) incelendiğinde, karşılaştırma bölümünün "mod" ve "ve" kasaları için eşit olduğunu ve Roy'un "veya" kutusu için biraz daha büyük olduğunu görebiliyordum:
// 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)
Ancak, bu üç seçeneği karşılaştırmak için gerçek bir kıyaslama çalıştırdıktan sonra (düz mod, bitsel veya bitsel ve), sonuçlar tamamen eşitti (yine, Visual Studio 2005 x86 / x64, Release build, hata ayıklayıcı eklenmedi).
Sürüm montajı, testtalimatlar andve modvakalar için talimatlar kullanırken Roy'un davası cmp eax,0FFFFFFFFhyaklaşımı kullanır , ancak pratik olarak hiçbir fark olmaması için ağır bir şekilde açılmış ve optimize edilmiştir.
20 çalıştırmadan sonraki sonuçlarım (i7 3610QM, Windows 10 güç planı Yüksek Performans olarak ayarlandı):
[Test: Düz mod 2] ORTALAMA SÜRESİ: 689,29 ms (Nispi fark: +% 0,000)
[Test: Bitsel veya] ORTALAMA SÜRESİ: 689,63 ms (Nispi fark: +% 0,048)
[Test: Bitsel ve] ORTALAMA SÜRESİ: 687,80 ms (Bağıl fark: -0.217%)
Bu seçenekler arasındaki fark% 0.3'ten azdır, bu nedenle montajın her durumda eşit olduğu açıktır.
İşte kimse denemek istiyorsa kod, ben sadece Windows üzerinde test bir uyarı ile ( tanım için #if LINUXkoşullu kontrol edin get_timeve gerekirse bu cevap alınan ).
#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;
}