सबसे सटीक कोड माप

मेरे लेख में छह महीने पहले लंबे अंकगणित पर, बहुत ही छोटे कोड के टुकड़ों की गति (थक्कों में थ्रूपुट) के माप हैं - बस कुछ निर्देश। माप तकनीक कुटिल थी, लेकिन प्रशंसनीय परिणाम दिया। फिर यह पता चला कि परिणाम अभी भी गलत थे - एक सतही दृष्टिकोण हमेशा प्रभावित करता है।

इस पोस्ट में, मैं न्यूनतम त्रुटि के साथ और विशेष पुस्तकालयों और ड्राइवरों को जोड़ने के बिना "नैनोबेनमार्किंग" की एक विश्वसनीय विधि का वर्णन करूंगा, जो आखिरकार मुझे मिला। प्रयोज्यता: प्रोसेसर की एकल-थ्रेडेड क्षमता की तुलना, बस ब्याज।

मैं केवल जीसीसी का उपयोग करता हूं - तदनुसार, इसके लिए विधि तेज है। लेकिन मैं सामान्यीकरण करूंगा ताकि अन्य संकलक के मालिक इसका पता लगा सकें।

---

प्रत्यक्ष उपाय आरडीटीसीटी टीम है। विकिपीडिया सही रूप से नोट करता है कि यह अविश्वसनीय है और विशेष ओएस सेवाओं का उपयोग करने की सिफारिश की जाती है। हालांकि, वे माइक्रोमर्बमेंट्स (घड़ी के सैकड़ों चक्र) के लिए बहुत लंबे समय तक काम करते हैं और शुरू से शुरू होने वाले समान नहीं हैं, जो घातक त्रुटियों का परिचय देता है। आरडीसीटीएस खुद कुछ दर्जन से अधिक चक्रों से काम नहीं करता है - एक निरंतर संख्या या एक छोटे सेट में से एक।

Micromeasurements में आरडीटीसी का एकमात्र दोष फ्लोटिंग प्रोसेसर घड़ी की गति है, क्योंकि समय स्टैंप काउंटर हमेशा मानक गुणक के अनुसार घड़ियों को गिनता है। एक गुणक को ठीक करना हमेशा एक तुच्छ कार्य नहीं है, अपने ओएस नाम और प्रोसेसर प्रकार के साथ संयोजन में " अक्षम सीपीयू स्केलिंग " देखें। ग्नोम में एक अच्छा समाधान indicator-cpufreq एपलेट है।

मापने वाले हार्नेस में तीन नेस्टेड लूप होते हैं।

आंतरिक लूप एक कार्य कार्यक्रम के रूप में डेटा के प्रवाह को नियंत्रित करता है।
इस भावना में:

 type input1[n]; type input2[n]; type output[n]; ... for (int i = 0; i < n; i++) {  input1[i]  input2[i]    output[i] } 

यह महत्वपूर्ण है कि वाक्यांश में "कोड को मापें", "कोड" इस लेख में प्रोसेसर निर्देशों का एक निश्चित अनुक्रम है। इसलिए, ब्रैकेट के बीच लूप का हिस्सा या तो असेंबलर या सी में लिखा जाना चाहिए, लेकिन आपको स्पष्ट रूप से समझना चाहिए कि आपको कंपाइलर से क्या मिल रहा है। -fno-prefetch-loop-arrays साथ GCC की उन्मत्त गतिविधि को दूर करने के लिए, तुरंत विकल्प -fno-prefetch-loop-arrays , -fno-unroll-loops , -ftree-vectorizer-verbose=1 । -fno-tree-vectorize -ftree-vectorize या -ftree-vectorize - आउटपुट की आवश्यकता के आधार पर - "जैसा कि यह लिखा गया है" या लूप के वेक्टर संस्करण।

यदि आप किसी इनपुट / आउटपुट के बिना किसी विशेष इनपुट या कोड के प्रसंस्करण को मापना चाहते हैं, तब भी इसे लूप में लपेटें। कोड को -fno-gcse करने से GCC को रोकने के लिए, -fno-gcse (वैश्विक सामान्य -fno-gcse एलिमिनेशन), -fno-tree-pta (पॉइंट्स-टू एनालिसिस), और -fno-tree-pre (आंशिक अतिरेक उन्मूलन) सक्षम करें। सभी अनुकूलन विकल्प देखें।

32 बाइट्स के साथ लूप की शुरुआत को संरेखित करें। -falign-loops ( -falign-loops ) के साथ, जीसीसी अपने दम पर ऐसा करता है।

मध्य चक्र में 2 माप चक्र और बीच में एक निरंतर आंतरिक चक्र होता है। इसकी भूमिका न्यूनतम समय निर्धारित करना है जिसके लिए आंतरिक चक्र पूरा किया जा सकता है। 20-30 पुनरावृत्तियों कैश में आने के लिए सभी डेटा के लिए पर्याप्त हैं, आरडीटीसीटी की शुरुआत और अंत में एक ही समय लगता है, और अन्य सभी सितारे एक साथ आते हैं अगर वे मौजूद हैं :-)

बाहरी लूप आंतरिक की लंबाई को नियंत्रित करता है। मध्य लूप से पहले इसमें इनपुट डेटा के आरंभीकरण को रखें।

बाहरी चक्र आवश्यक है क्योंकि मध्य चक्र में पहुंचने वाले समय में हमेशा एक स्थिर शामिल होता है - आंतरिक चक्र का आरंभीकरण समय + संक्रमण की भविष्यवाणी करने में 1 त्रुटि की लागत (सबसे बुद्धिमान इंटेल कोर कम गलतियां करते हैं)। इसलिए, मध्य चक्र से समय को पुनरावृत्तियों की संख्या से विभाजित नहीं किया जा सकता है।

लेकिन यह भी सब नहीं है! आंतरिक छोरों के निष्पादन समय में अंतर, 1 पुनरावृत्ति द्वारा लंबाई में अंतर, अक्सर महत्वपूर्ण रूप से भिन्न होता है। कारण एक दूसरे पर कन्वेयर के विभिन्न चरणों का प्रभाव है। ऐसे समय में, जब किसी स्तर पर, विचार काम करना है, तो वास्तव में निम्नलिखित हो सकता है:

• डाटा प्रोसेसिंग
• सरल, क्योंकि अगला चरण अभी भी व्यस्त है,
• सरल, क्योंकि पिछले चरण का डेटा नहीं आया था।

इसके अलावा, कुछ चरणों में असामान्य व्यवहार होता है, जैसे कि एक संक्रमण पूर्वसूचक और माइक्रो-ऑपरेशन शेड्यूलर। यह सब जटिल प्रभाव को जन्म देता है।

नतीजतन, 1 से 10-15 (?) की लंबाई के साथ काम का एक "पैटर्न" कन्वेयर पर सेट किया गया है:

यह समझ में आता है कि कम से कम 1 ऐसे पैटर्न के लिए टिक्स में सटीक थ्रूपुट की गिनती करें, न कि 1 पुनरावृत्ति।

जैसा कि आप नीचे दिए गए उदाहरणों में संख्याओं से आसानी से देख सकते हैं, यहां तक ​​कि पैटर्न को मापने के दौरान भी, परिणाम बिखरे रहते हैं। संभवतः आरडीसीटी वास्तव में उतना अच्छा नहीं है जितना कि ऊपर वर्णित :-)

इसलिए, आंतरिक चक्रों के निष्पादन समय में उन अंतरों को प्राप्त किया गया है जो पैटर्न के कदम के गुणक हैं, यह आँकड़ों की गणना करने के लिए रहता है।

उदाहरण

माप के परिणामों की तुलना करें (बाद में उपायों में सभी मान) लंबे अंकगणित के बारे में लेख से:

सतह की विधि	7.5	5.5	5.5	7	5	2	2.5	3.25 (?) - 3.5
स्मार्ट विधि	7	6	6	7	5	2	2	3

आगे के सभी परीक्षण 2 कोर पर किए गए: एएमडी के 10 और इंटेल कोर 2 वोल्फडेल ।

औजारों का मूल्यांकन स्वयं करना महत्वपूर्ण है।

खाली पाश

भीतरी लूप इस तरह दिखता है:

 for (int i = 0; i < inner_len; i++) { asm volatile ( "" ); } 

 के 10 1.8 10 0.7
 10 पुनरावृत्तियों में कोर 2 10.0 ± 2.4।

इसके अलावा (10, 1.0) - (पैटर्न की लंबाई, कुल 1 पुनरावृत्ति का औसत)

RDTSC

मध्यम और आंतरिक चक्र के बिना:

 typedef unsigned long long ull; inline ull rdtsc() { unsigned int lo, hi; asm volatile ( "rdtsc\n" : "=a" (lo), "=d" (hi) ); return ((ull)hi << 32) | lo; } ... for (int i = 0; i < TOTAL_VALUES; i++) { ull t1 = rdtsc(); ull t2 = rdtsc(); printf("%lld\n", t2 - t1); } 

 के 10 69.7 ± 1.5
 कोर 2 31.0 ± 0.3

अनुमानित साइन गणना

यह देखना दिलचस्प है कि टेलर 3 के आदेश के बाद साइन की गणना करके आप कितना बचा सकते हैं। Ang / 2 से π / 2 के कोण पर, 2 दशमलव स्थानों की सटीकता प्राप्त की जाती है। आप अनुप्रयोगों की कल्पना कर सकते हैं जहां यह पर्याप्त होगा।

फ्रेम:

 #include <cstdio> #include <cstdlib> #include <cmath> #include <limits> typedef unsigned long long ull; #define MIDDLE_LEN (20) #define TOTAL_VALUES (10000) #define VEC_LEN (1) // len in _numbers_ #define DATA_LEN (TOTAL_VALUES * VEC_LEN) inline ull rdtsc() { unsigned int lo, hi; asm volatile ( "rdtsc\n" : "=a" (lo), "=d" (hi) ); return ((ull)hi << 32) | lo; } typedef double my_float; #define BYTE_LEN (DATA_LEN * sizeof(my_float)) int main() { my_float *angles = (my_float *) malloc(BYTE_LEN); my_float *sines = (my_float *) malloc(BYTE_LEN);   for (int inner_len = 0; inner_len < DATA_LEN; inner_len += VEC_LEN) { for (int i = 0; i < inner_len; i++)  angles[i] ull inner_min = std::numeric_limits<ull>::max(); for (int mi = 0; mi < MIDDLE_LEN; mi++) { ull t1 = rdtsc(); for (int i = 0; i < inner_len; i += VEC_LEN) {   angles[i]  sines[i] } ull t = rdtsc() - t1; inner_min = t < inner_min ? t : inner_min; } //     printf("%lld\n", inner_min); } } 

FSIN निर्देश - सटीक साइन

यह वह है जिसे math.h से sin कहा जाता है। उत्पन्न माइक्रोएरे शायद साइन के इस कार्यान्वयन से मिलता जुलता है, क्योंकि निष्पादन की गति भी कोण पर निर्भर करती है। इसलिए, यदि एक ही कोण के साइन को लूप में गणना की जाती है, तो एक सटीक थ्रूपुट समझ में आता है। कोण से स्वतंत्र गणना के साथ तुलना के लिए एक यादृच्छिक कोण पर औसत की आवश्यकता होती है।

 //  my_float randoms[DATA_LEN]; for (int i = 0; i < DATA_LEN; i++) randoms[i] = rand() / 2.0 / RAND_MAX * M_PI; //   angles[i] = 0.0  0.0001  M_PI * 0.5  randoms[i]; //   asm volatile ( "fldl (%0)\n\t" "fsin\n\t" "fstpl (%1)\n\t" :: "r" (angles + i), "r" (sines + i) ); 

कोण	0.0	0.0001	π / 2	बिना सोचे समझे
K10	30.2 .3 10.3	89.8 ± 2.9	143.1 (8.5 (2, 71.6)	75.6
कोर 2	40.0 .0 11.0	68.0 ± 5.6	88.0 .0 13.0	89.4

तृतीय क्रम टेलर श्रृंखला

 //  my_float d6 = 1.0 / 6.0; my_float d120 = 1.0 / 120.0; my_float randoms[DATA_LEN]; for (int i = 0; i < DATA_LEN; i++) randoms[i] = rand() / 2.0 / RAND_MAX * M_PI; //   angles[i] = randoms[i]; //   my_float x = angles[i]; sines[i] = x - x*x*x*d6 + x*x*x*x*x*d120; 

K10	61.2 ± 15.6 (8, 7.7 )
कोर 2	35.2 ± 16.8 (4, 8.8 )

सदिश टेलर श्रृंखला

बस GCC -ftree-vectorize विकल्प को जोड़ना अनिवार्य रूप से एक ही परिणाम होगा (ऊपर देखें)। और यहाँ वेक्टर एक्सटेंशन का उपयोग किया जाता है ।

 #define VEC_LEN (2) typedef my_float float_vector __attribute__ ((vector_size (16))); ... //  float_vector d6_v = {1.0 / 6.0, 1.0 / 6.0}; float_vector d120_v = {1.0 / 120.0, 1.0 / 120.0}; my_float randoms[DATA_LEN]; for (int i = 0; i < DATA_LEN; i++) randoms[i] = rand() / 2.0 / RAND_MAX * M_PI; //   angles[i] = randoms[i]; //   float_vector x = *((float_vector *)(angles + i)); *((float_vector *)(sines + i)) = x - x*x*x*d6_v + x*x*x*x*x*d120_v; 

K10	41.8 .2 14.2 (5, 8.4, 4.2 प्रति 1 साइन)
कोर 2	44.3 .6 16.6 (5, 8.9, 4.5 )

स्केलर संस्करण की तुलना में 1 पुनरावृत्ति की गति थोड़ी कम है, और 1 कोण के साइन की गणना लगभग 2 गुना अधिक है।

यह पता चला है कि 2 वर्णों की सटीकता के साथ साइन की गणना सामान्य से कम से कम 10 गुना तेज आयोजित की जा सकती है।

सूत्रों का कहना है

• अगनर कोहरा। सॉफ्टवेयर अनुकूलन संसाधन
• AMD64 आर्किटेक्चर प्रोग्रामर मैनुअल

अधिक लिंक

• Intel® 64 और IA-32 आर्किटेक्चर सॉफ्टवेयर डेवलपर मैनुअल
• त्रिकोणमितीय कार्य कैसे करते हैं?

पुनश्च

वर्णित विधि कोड को प्रोफाइल नहीं करती है । अनुकूलन के साथ मदद करने की संभावना भी बेहद कम है , क्योंकि अगर प्रदर्शन कंप्यूटिंग पाइपलाइन पर टिकी हुई है, तो हमेशा सामान्य घड़ी () - प्रति चक्र पुनरावृत्तियों के साथ समाधान की तुलना करना संभव है।