Ini adalah tindak lanjut dari diskusi dengan @RocketRoy mengenai jawabannya , tetapi mungkin bermanfaat bagi siapa saja yang ingin membandingkan hasil ini.
tl; dr Dari apa yang saya lihat, pendekatan Roy ( (0xFFFFFFFF == (x | 0xFFFFFFFE)) tidak sepenuhnya dioptimalkan x & 1sebagai modpendekatan, tetapi dalam praktiknya waktu berjalan seharusnya menjadi sama dalam semua kasus.
Jadi, pertama saya membandingkan output yang dikompilasi menggunakan Compiler Explorer :
Fungsi yang diuji:
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));
}
Klik 3.9.0 dengan -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 dengan -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
Angkat ke CLang, itu menyadari bahwa ketiga kasus secara fungsional sama. Namun, pendekatan Roy tidak dioptimalkan dalam GCC, begitu YMMV.
Ini mirip dengan Visual Studio; memeriksa Rilis pembongkaran x64 (VS2015) untuk tiga fungsi ini, saya bisa melihat bahwa bagian perbandingannya sama untuk case "mod" dan "dan", dan sedikit lebih besar untuk case Roy "atau":
// 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)
Namun, setelah menjalankan tolok ukur yang sebenarnya untuk membandingkan tiga opsi ini (mod sederhana, bitwise atau, bitwise dan), hasilnya benar-benar sama (sekali lagi, Visual Studio 2005 x86 / x64, rilis Rilis, tidak ada debugger terpasang).
Majelis rilis menggunakan testinstruksi untuk anddan modkasus, sedangkan kasus Roy menggunakancmp eax,0FFFFFFFFh pendekatan, tetapi sangat terbuka dan dioptimalkan sehingga tidak ada perbedaan dalam prakteknya.
Hasil saya setelah 20 berjalan (i7 3610QM, rencana daya Windows 10 diatur ke Kinerja Tinggi):
[Tes: Plain mod 2] WAKTU RATA-RATA: 689,29 ms (Perbedaan relatif .: + 0,000%)
[Tes: Bitwise atau] WAKTU RATA-RATA: 689,63 ms (Perbedaan relatif .: + 0,048%)
[Tes: Bitwise dan] WAKTU RATA-RATA: 687,80 ms (Perbedaan relatif .: -0,217%)
Perbedaan antara opsi-opsi ini kurang dari 0,3%, jadi agak jelas rakitannya sama dalam semua kasus.
Berikut adalah kode jika ada yang ingin mencoba, dengan peringatan bahwa saya hanya mengujinya pada Windows (periksa #if LINUXpersyaratan untuk get_timedefinisi dan menerapkannya jika perlu, diambil dari jawaban ini ).
#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;
}