এটি তার উত্তর সম্পর্কে @ রকেটরোয়ের সাথে আলোচনার ফলোআপ , তবে যারা এই ফলাফলগুলি তুলনা করতে চান তাদের পক্ষে এটি কার্যকর হতে পারে।
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));
}
-ও 3 সহ ক্লাং 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
ওসি 3 সহ জিসিসি 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
ক্লাং-এর কাছে হ্যাটস, এটি বুঝতে পেরেছিল যে তিনটি ক্ষেত্রেই কার্যত সমান। যাইহোক, রায়ের দৃষ্টিভঙ্গি জিসিসিতে অনুকূলিত হয়নি, তাই ওয়াইএমএমভি।
ভিজ্যুয়াল স্টুডিওর সাথে এটি একই রকম; এই তিনটি ফাংশনের জন্য বিচ্ছিন্নতা প্রকাশ 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] গড় সময়: 689.29 এমএস (আপেক্ষিক পার্থক্য: + 0.000%)
[পরীক্ষা: বিটওয়াইস বা] গড় সময়: 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;
}