이것은 @RocketRoy 와의 답변 에 대한 후속 조치 이지만 이러한 결과를 비교하려는 사람에게는 유용 할 수 있습니다.
TL; DR 내가 본 바로는이 로이의 접근 방식은 ( (0xFFFFFFFF == (x | 0xFFFFFFFE)) 완전히 최적화되지 x & 1는 AS 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));
}
-O3을 포함한 CLang 3.9.0 :
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을 사용하는 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에 이르기까지 세 가지 경우 모두 기능적으로 동일하다는 것을 깨달았습니다. 그러나 Roy의 접근 방식은 GCC에서 최적화되지 않으므로 YMMV입니다.
Visual Studio와 비슷합니다. 이 세 가지 기능에 대한 디스 어셈블리 릴리스 x64 (VS2015)를 검사하면 비교 부분이 "mod"및 "and"경우와 같고 Roy의 "or"경우에는 약간 더 큽니다.
// 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사례를 사용하지만 Roy의 사례는 cmp eax,0FFFFFFFFh접근 방식을 사용 하지만 크게 풀리고 최적화되어 실제로 차이가 없습니다.
20 회 실행 후 결과 (i7 3610QM, Windows 10 전원 관리 옵션이 고성능으로 설정 됨) :
[테스트 : Plain mod 2] 평균 시간 : 689.29 ms (상대 차이 : + 0.000 %)
[테스트 : 비트 단위 또는] 평균 시간 : 689.63 ms (상대 차이 : + 0.048 %)
[테스트 : 비트 및] 평균 시간 : 687.80 ms (상대 차이 : -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;
}