यह उनके उत्तर के संबंध में @RocketRoy के साथ चर्चा करने के लिए अनुवर्ती है , लेकिन यह उन लोगों के लिए उपयोगी हो सकता है जो इन परिणामों की तुलना करना चाहते हैं।
tl; dr जो मैंने देखा है, उससे रॉय का दृष्टिकोण ( (0xFFFFFFFF == (x | 0xFFFFFFFE)) पूरी तरह x & 1से 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));
}
CLO 3.9.0 -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 -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
सलाम क्लैंग के लिए, यह महसूस किया कि सभी तीन मामले कार्यात्मक रूप से बराबर हैं। हालाँकि, रॉय का दृष्टिकोण GCC में अनुकूलित नहीं है, इसलिए YMMV।
यह विज़ुअल स्टूडियो के साथ समान है; इन तीन फ़ंक्शंस के लिए डिस्सैम्फ़र रिलीज़ x64 (VS2015) का निरीक्षण करते हुए, मैं देख सकता था कि तुलना भाग "मॉड" और "और" मामलों के लिए बराबर है, और रॉय के "या" केस के लिए थोड़ा बड़ा है:
// 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)
हालाँकि, इन तीन विकल्पों (सादे मॉड, बिटवाइज़ या बिटवाइज़ और) की तुलना करने के लिए एक वास्तविक बेंचमार्क चलाने के बाद, परिणाम पूरी तरह से बराबर थे (फिर से, विजुअल स्टूडियो 2005 x86 / x64, रिलीज़ बिल्ड, कोई डीबगर संलग्न नहीं)।
रिलीज़ असेंबली testनिर्देश andऔर modमामलों का उपयोग करती है, जबकि रॉय का केस उपयोग करता हैcmp eax,0FFFFFFFFh दृष्टिकोण , लेकिन यह बहुत अधिक अनियंत्रित और अनुकूलित है, इसलिए व्यवहार में कोई अंतर नहीं है।
20 रन (i7 3610QM, विंडोज 10 पावर प्लान टू हाई परफॉर्मेंस) के बाद मेरे परिणाम:
[टेस्ट: प्लेन मॉड 2] एवरेज टाइम: ६9 ९ .२ ९ एमएस (सापेक्ष भिन्नता: + ०.०००%)
[टेस्ट: बिटवाइज़ या] एवरेज टाइम: 689.63 एमएस (सापेक्ष अंतर।: + 0.048%)
[टेस्ट: बिटवाइज़ और] एवरेज टाइम: 687.80 एमएस (सापेक्ष भिन्नता: -0.217%)
इन विकल्पों के बीच अंतर 0.3% से कम है, इसलिए यह स्पष्ट है कि विधानसभा सभी मामलों में समान है।
यहां वह कोड है यदि कोई भी कोशिश करना चाहता है, एक चेतावनी के साथ कि मैंने केवल इसे विंडोज पर परीक्षण किया है ( परिभाषा के #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;
}