Đây là phần tiếp theo cuộc thảo luận với @RocketRoy về câu trả lời của anh ấy , nhưng nó có thể hữu ích cho bất kỳ ai muốn so sánh các kết quả này.
tl; dr Từ những gì tôi đã thấy, cách tiếp cận của Roy ( (0xFFFFFFFF == (x | 0xFFFFFFFE)) không hoàn toàn được tối ưu hóa x & 1như modcách tiếp cận, nhưng trong thực tế, thời gian chạy sẽ trở nên bình đẳng trong mọi trường hợp.
Vì vậy, trước tiên tôi đã so sánh đầu ra được biên dịch bằng Compiler Explorer :
Chức năng được kiểm tra:
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 với -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 với -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
Ngả mũ xuống CLang, nó nhận ra rằng cả ba trường hợp đều có chức năng như nhau. Tuy nhiên, cách tiếp cận của Roy không được tối ưu hóa trong GCC, vì vậy YMMV.
Nó tương tự với Visual Studio; kiểm tra bản phát hành tháo gỡ x64 (VS2015) cho ba chức năng này, tôi có thể thấy rằng phần so sánh bằng với các trường hợp "mod" và "và", và lớn hơn một chút cho trường hợp "hoặc" của 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)
Tuy nhiên, sau khi chạy một điểm chuẩn thực tế để so sánh ba tùy chọn này (mod đơn giản, bitwise hoặc, bitwise và), kết quả hoàn toàn bằng nhau (một lần nữa, Visual Studio 2005 x86 / x64, Bản dựng phát hành, không có trình gỡ lỗi đính kèm).
Tập hợp phát hành sử dụng testhướng dẫn cho andvà modcác trường hợp, trong khi trường hợp của Roy sử dụng cmp eax,0FFFFFFFFhcách tiếp cận, nhưng nó không được kiểm soát và tối ưu hóa nhiều nên không có sự khác biệt trong thực tế.
Kết quả của tôi sau 20 lần chạy (i7 3610QM, gói điện năng Windows 10 được đặt thành Hiệu suất cao):
[Kiểm tra: Plain mod 2] THỜI GIAN AVERAGE: 689,29 ms (Tương đối khác: + 0,000%)
[Kiểm tra: Bitwise hoặc] THỜI GIAN AVERAGE: 689,63 ms (Tương đối khác: + 0,048%)
[Kiểm tra: Bitwise và] THỜI GIAN AVERAGE: 687,80 ms (Khác biệt tương đối: -0,217%)
Sự khác biệt giữa các tùy chọn này nhỏ hơn 0,3%, do đó, rõ ràng việc lắp ráp là bằng nhau trong mọi trường hợp.
Đây là mã nếu bất cứ ai muốn thử, với một cảnh báo mà tôi chỉ kiểm tra nó trên Windows (kiểm tra #if LINUXđiều kiện cho get_timeđịnh nghĩa và thực hiện nó nếu cần, lấy từ câu trả lời này ).
#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;
}