पूर्णांक गुणन के प्रदर्शन की तुलना करें

जब मैंने इस लेख के लिए एक परीक्षण कार्यक्रम लिखना शुरू किया, तो मुझे आंतरिक रूप से उम्मीद थी कि इंटेल के सीपीयू दोनों ब्लेडों पर एएमडी डाल देंगे, जैसे कि एक ही नाम के कंपाइलर विजुअल स्टूडियो को बिना किसी लड़ाई के हरा देगा। लेकिन सब कुछ इतना सरल नहीं है, शायद एक सॉफ्टवेयर परीक्षण की पसंद ने इसे प्रभावित किया?

परीक्षण के लिए, मैंने 256-बिट परिणाम प्राप्त करने के लिए दो 128-बिट संख्याओं के पूर्णांक गुणन का उपयोग किया। परीक्षण को 1 बिलियन बार दोहराया गया और केवल 12 से 85 सेकंड का समय लगा। इस्तेमाल किए गए प्रोसेसर AMD FX-8150 3.60GHz और Intel Core i5 2500 3.30GHz थे। कोई मल्टीथ्रेडिंग, कोई ओवरक्लॉकिंग नहीं।

उपयोग किए गए संकलक इंटेल पैरेलल स्टूडियो XE संस्करण 12.0.0.104 बिल्ड 20101006, इसके नए पुनर्जन्म 12.1.5.344 बिल्ड 20120612, विज़ुअल स्टूडियो 2010 SP1 और सबसे आधुनिक विज़ुअल स्टूडियो 2012 (मेट्रो इंटरफ़ेस और CAPSLOCK मेनू के साथ) थे, यह C ++ 11.0 रिलीज़ उम्मीदवार भी है। हम -O2 विकल्प के बारे में नहीं भूलते, यह विजुअल स्टूडियो में सक्षम है। और Intel के लिए यह आवश्यक नहीं है, यह -O2 के साथ डिफ़ॉल्ट रूप से अनुकूलन करता है, Intel के लिए -O3 विकल्प सक्षम है।

मैं खुद ही टेस्ट दूंगा। मैं मानता हूं कि 64-बिट कोड के लिए बीएन_वॉर्ड को __int64 के बराबर बनाना आवश्यक होगा, फिर बीएन_वॉर्ड को निम्न और उच्च भागों में विभाजित करें, और इस अर्थव्यवस्था को _mul128 नामक आंतरिक का उपयोग करने के लिए गुणा करें, जो इन कंपाइलरों द्वारा समर्थित है। यह सब योजनाओं में है और बाद में किया जाना चाहिए। इस लेख का उद्देश्य संकलक के अनुकूलन की तुलना करना है, लेकिन 32-बिट और 64-बिट गुणन की गति की तुलना नहीं करना है, साथ ही साथ एक मिथक को नष्ट करना है।

#include <stdio.h> #include <windows.h> #define QUANTITY 4 typedef unsigned int BN_WORD; typedef unsigned __int64 BN_DWORD; void Mul(BN_WORD *C, BN_WORD *A, BN_WORD *B ) { BN_WORD Carry = 0; BN_WORD h = *(B++); int i, j; union { BN_DWORD sd; BN_WORD sw[2]; } s; for( i = QUANTITY; i > 0; --i) { s.sd = (BN_DWORD) *(A++) * h + Carry; *C++ = s.sw[0]; Carry = s.sw[1]; } *C = Carry; for ( j = QUANTITY-1; j > 0; --j ) { A -= QUANTITY; h = *(B++); C -= QUANTITY-1; Carry = 0; for( i = QUANTITY; i > 0; --i ) { s.sd = (BN_DWORD) *(A++) * h + *C + Carry; *C++ = s.sw[0]; Carry = s.sw[1]; } *C = Carry; } } typedef void (*my_proc)(BN_WORD*, BN_WORD*, BN_WORD*); void put_addr(void) { FILE *f=fopen("tmp.$$$", "wb"); my_proc proc = Mul; fwrite(&proc, 1, sizeof(proc), f); fclose(f); } my_proc get_addr(void) { FILE *f=fopen("tmp.$$$", "rb"); my_proc proc = NULL; fread(&proc, 1, sizeof(proc), f); fclose(f); return proc; } int main(void) { int i,j; LARGE_INTEGER lFrequency, lStart, lEnd; double dfTime1; BN_WORD A[QUANTITY], B[QUANTITY], C[QUANTITY*2]; BN_WORD RES[QUANTITY*2]={0xd7a44a41, 0xf6e4895c, 0x1624c878, 0x35650795, 0xa55cb22f, 0x861c7313, 0x66dc33f7, 0x479bf4db }; // ,   inline    Mul   main void (*mul)( BN_WORD *C, BN_WORD *A, BN_WORD *B ); put_addr(); mul = get_addr(); for( i=0; i<QUANTITY; ++i) { A[i] = B[i] = 0x87654321; } QueryPerformanceFrequency(&lFrequency); QueryPerformanceCounter(&lStart); for( i=0; i<1000; ++i) { for( j=0; j<1000000; ++j) { mul(C, A, B); } if (memcmp(RES, C, sizeof(RES))!=0) { printf("Something wrong!\n"); } } QueryPerformanceCounter(&lEnd); dfTime1 = (double)(lEnd.QuadPart - lStart.QuadPart) / (double)lFrequency.QuadPart; printf("Time = %g sec\n", dfTime1); } 

परिणाम तालिका में दिखाए गए हैं:

	AMD FX-8150 3.60GHz 64 बिट	AMD FX-8150 3.60GHz 32 बिट	कोर i5-2500 3.30GHz 64 बिट	कोर i5-2500 3.30GHz 32 बिट
इंटेल समानांतर स्टूडियो XE 12.0.0.104 बिल्ड 20101006	22.6235 सेकंड	25.913 सेकंड	13.0921 सेकंड	23.1986 सेकंड
इंटेल समानांतर स्टूडियो XE 12.1.5.344 बिल्ड 20120612	22.2398 सेकंड	26.0347 सेकंड	12.9242 सेकंड	23.1603 सेकंड
दृश्य स्टूडियो 2010 C ++ 10.0 SP1	22.5853 सेक	84.1714 सेकेंड	12.4991 सेकंड	53.633 सेकंड
विजुअल स्टूडियो 2012 सी ++ 11.0 रिलीज़ उम्मीदवार	22.2952 सेकंड	72.8279 सेकंड	12.6212 सेकंड	47.1136 सेकंड

64-बिट कोड पर, हमारे पास तीनों संकलक के लिए लगभग समान परिणाम है।

इंटेल 32 बिट पर महत्वपूर्ण रूप से जीतता है, VS2010 इसके पीछे बुनाई करता है, और नवीनतम VS2012 स्थिर विकास दिखाता है, हालांकि यह इंटेल से बहुत दूर है।

एएमडी और कोर आई 5 पर काम की गति की तुलना करना भी दिलचस्प है। 7000 रूबल की समान कीमत पर, प्रोसेसर इंटेल कंपाइलर पर 32-बिट अनुप्रयोगों में समान प्रदर्शन दिखाते हैं। हालांकि यह उम्मीद की जा रही थी कि सिंगल थ्रेडेड टेस्ट में हमेशा कोर i5 का फायदा रहेगा। 8 एएमडी कोर की पूर्ण शक्ति का उपयोग करने के लिए एक बहु-थ्रेडेड परीक्षण लिखने की योजना है। और फिर उसके जीतने की संभावना है, क्योंकि उसके पास 8 पूर्णांक अंकगणित कोर (लेकिन 4 फ्लोटिंग-पॉइंट कोर) बनाम 4 कोर कोर 5 में हैं, मल्टी-थ्रेडिंग कोर i5 का समर्थन नहीं करता है।

एक अन्य महत्वपूर्ण निष्कर्ष स्वयं पता चलता है: कंपाइलर निर्माताओं ने समान परिणाम प्राप्त करते हुए, 64-बिट कंपाइलर बनाने के लिए अपने सभी प्रयासों को समर्पित किया है। प्रोसेसर निर्माताओं ने भी अपने सभी बलों को 64-बिट प्लेटफ़ॉर्म में फेंक दिया, जबकि इंटेल ने एएमडी को बेहतर रूप से पीछे छोड़ दिया।

एक और दिलचस्प तथ्य यह है कि इस मिथक पर बहस की जाती है कि इंटेल कंपाइलर माना जाता है कि कोड केवल इंटेल पर अच्छा काम करता है और एएमडी (2 या अधिक बार धीमी) पर विस्मयकारी प्रदर्शन दिखाता है। यह देखना आसान है कि 32-बिट कोड पर इंटेल कंपाइलर एएमडी से इंटेल सीपीयू पर स्विच करने पर लगभग एक ही परिणाम देता है, लेकिन वीएस कंपाइलर कोर आई 5 पर महत्वपूर्ण त्वरण का पता लगाना संभव नहीं था, अगर वीएस से कोड का उपयोग किया जाता है। (वास्तव में, क्यों?)

UPD1। इस लेख के पहले संस्करण में, इस तथ्य के कारण एक त्रुटि सामने आई कि चालाक अनुकूलन के कारण, VS2010 ने गुणा नहीं किया और कोड 5.5 गुना तेजी से निकला। अब स्रोत तय हो गया है (f-ju Mul के लिए mul पॉइंटर पेश किया गया है, और कंपाइलर को मूर्ख बनाने के लिए पॉइंटर को फ़ाइल से लिखा / पढ़ा जाता है), परिणाम अपडेट किए जाते हैं। और _WORD को पूरी स्पष्टता के लिए BN_WORD के लिए सही किया गया है, पहली टिप्पणी से देखते हुए।